X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Fmodule.c;h=04c9ea5f68ec1745f5d806f1b0f5641bb20eba23;hb=a3850a044ef7cc2658b355672338b9865ed59fe4;hp=2529b38ecd40809b6fc9a0af3cf0dcfe37505846;hpb=e3a7c58aebafce40323db54bf6056029e5af4a70;p=fs%2Flustre-release.git

diff --git a/libcfs/libcfs/module.c b/libcfs/libcfs/module.c
index 2529b38..04c9ea5 100644
--- a/libcfs/libcfs/module.c
+++ b/libcfs/libcfs/module.c
@@ -26,18 +26,18 @@
 /*
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2012, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
  * Lustre is a trademark of Sun Microsystems, Inc.
  */
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
 #define DEBUG_SUBSYSTEM S_LNET
 
 #include <libcfs/libcfs.h>
+#include <libcfs/libcfs_crypto.h>
 #include <lnet/lib-lnet.h>
 #include <lnet/lnet.h>
 #include "tracefile.h"
@@ -45,159 +45,158 @@
 void
 kportal_memhog_free (struct libcfs_device_userstate *ldu)
 {
-        cfs_page_t **level0p = &ldu->ldu_memhog_root_page;
-        cfs_page_t **level1p;
-        cfs_page_t **level2p;
-        int           count1;
-        int           count2;
+	struct page **level0p = &ldu->ldu_memhog_root_page;
+	struct page **level1p;
+	struct page **level2p;
+	int           count1;
+	int           count2;
 
-        if (*level0p != NULL) {
+	if (*level0p != NULL) {
+		level1p = (struct page **)page_address(*level0p);
+		count1 = 0;
 
-                level1p = (cfs_page_t **)cfs_page_address(*level0p);
-                count1 = 0;
+		while (count1 < PAGE_CACHE_SIZE/sizeof(struct page *) &&
+		       *level1p != NULL) {
 
-                while (count1 < CFS_PAGE_SIZE/sizeof(cfs_page_t *) &&
-                       *level1p != NULL) {
+			level2p = (struct page **)page_address(*level1p);
+			count2 = 0;
 
-                        level2p = (cfs_page_t **)cfs_page_address(*level1p);
-                        count2 = 0;
+			while (count2 < PAGE_CACHE_SIZE/sizeof(struct page *) &&
+			       *level2p != NULL) {
 
-                        while (count2 < CFS_PAGE_SIZE/sizeof(cfs_page_t *) &&
-                               *level2p != NULL) {
-
-                                cfs_free_page(*level2p);
-                                ldu->ldu_memhog_pages--;
-                                level2p++;
-                                count2++;
-                        }
+				__free_page(*level2p);
+				ldu->ldu_memhog_pages--;
+				level2p++;
+				count2++;
+			}
 
-                        cfs_free_page(*level1p);
-                        ldu->ldu_memhog_pages--;
-                        level1p++;
-                        count1++;
-                }
+			__free_page(*level1p);
+			ldu->ldu_memhog_pages--;
+			level1p++;
+			count1++;
+		}
 
-                cfs_free_page(*level0p);
-                ldu->ldu_memhog_pages--;
+		__free_page(*level0p);
+		ldu->ldu_memhog_pages--;
 
-                *level0p = NULL;
-        }
+		*level0p = NULL;
+	}
 
-        LASSERT (ldu->ldu_memhog_pages == 0);
+	LASSERT(ldu->ldu_memhog_pages == 0);
 }
 
 int
 kportal_memhog_alloc (struct libcfs_device_userstate *ldu, int npages, int flags)
 {
-        cfs_page_t **level0p;
-        cfs_page_t **level1p;
-        cfs_page_t **level2p;
-        int           count1;
-        int           count2;
+	struct page **level0p;
+	struct page **level1p;
+	struct page **level2p;
+	int           count1;
+	int           count2;
 
-        LASSERT (ldu->ldu_memhog_pages == 0);
-        LASSERT (ldu->ldu_memhog_root_page == NULL);
+	LASSERT(ldu->ldu_memhog_pages == 0);
+	LASSERT(ldu->ldu_memhog_root_page == NULL);
 
-        if (npages < 0)
-                return -EINVAL;
+	if (npages < 0)
+		return -EINVAL;
 
-        if (npages == 0)
-                return 0;
+	if (npages == 0)
+		return 0;
 
-        level0p = &ldu->ldu_memhog_root_page;
-        *level0p = cfs_alloc_page(flags);
-        if (*level0p == NULL)
-                return -ENOMEM;
-        ldu->ldu_memhog_pages++;
+	level0p = &ldu->ldu_memhog_root_page;
+	*level0p = alloc_page(flags);
+	if (*level0p == NULL)
+		return -ENOMEM;
+	ldu->ldu_memhog_pages++;
 
-        level1p = (cfs_page_t **)cfs_page_address(*level0p);
-        count1 = 0;
-        memset(level1p, 0, CFS_PAGE_SIZE);
+	level1p = (struct page **)page_address(*level0p);
+	count1 = 0;
+	memset(level1p, 0, PAGE_CACHE_SIZE);
 
-        while (ldu->ldu_memhog_pages < npages &&
-               count1 < CFS_PAGE_SIZE/sizeof(cfs_page_t *)) {
+	while (ldu->ldu_memhog_pages < npages &&
+	       count1 < PAGE_CACHE_SIZE/sizeof(struct page *)) {
 
-                if (cfs_signal_pending())
-                        return (-EINTR);
+		if (cfs_signal_pending())
+			return -EINTR;
 
-                *level1p = cfs_alloc_page(flags);
-                if (*level1p == NULL)
-                        return -ENOMEM;
-                ldu->ldu_memhog_pages++;
+		*level1p = alloc_page(flags);
+		if (*level1p == NULL)
+			return -ENOMEM;
+		ldu->ldu_memhog_pages++;
 
-                level2p = (cfs_page_t **)cfs_page_address(*level1p);
-                count2 = 0;
-                memset(level2p, 0, CFS_PAGE_SIZE);
+		level2p = (struct page **)page_address(*level1p);
+		count2 = 0;
+		memset(level2p, 0, PAGE_CACHE_SIZE);
 
-                while (ldu->ldu_memhog_pages < npages &&
-                       count2 < CFS_PAGE_SIZE/sizeof(cfs_page_t *)) {
+		while (ldu->ldu_memhog_pages < npages &&
+		       count2 < PAGE_CACHE_SIZE/sizeof(struct page *)) {
 
-                        if (cfs_signal_pending())
-                                return (-EINTR);
+			if (cfs_signal_pending())
+				return -EINTR;
 
-                        *level2p = cfs_alloc_page(flags);
-                        if (*level2p == NULL)
-                                return (-ENOMEM);
-                        ldu->ldu_memhog_pages++;
+			*level2p = alloc_page(flags);
+			if (*level2p == NULL)
+				return -ENOMEM;
+			ldu->ldu_memhog_pages++;
 
-                        level2p++;
-                        count2++;
-                }
+			level2p++;
+			count2++;
+		}
 
-                level1p++;
-                count1++;
-        }
+		level1p++;
+		count1++;
+	}
 
-        return 0;
+	return 0;
 }
 
 /* called when opening /dev/device */
 static int libcfs_psdev_open(unsigned long flags, void *args)
 {
-        struct libcfs_device_userstate *ldu;
-        ENTRY;
+	struct libcfs_device_userstate *ldu;
+	ENTRY;
 
-        PORTAL_MODULE_USE;
+	try_module_get(THIS_MODULE);
 
-        LIBCFS_ALLOC(ldu, sizeof(*ldu));
-        if (ldu != NULL) {
-                ldu->ldu_memhog_pages = 0;
-                ldu->ldu_memhog_root_page = NULL;
-        }
-        *(struct libcfs_device_userstate **)args = ldu;
+	LIBCFS_ALLOC(ldu, sizeof(*ldu));
+	if (ldu != NULL) {
+		ldu->ldu_memhog_pages = 0;
+		ldu->ldu_memhog_root_page = NULL;
+	}
+	*(struct libcfs_device_userstate **)args = ldu;
 
-        RETURN(0);
+	RETURN(0);
 }
 
 /* called when closing /dev/device */
 static int libcfs_psdev_release(unsigned long flags, void *args)
 {
-        struct libcfs_device_userstate *ldu;
-        ENTRY;
+	struct libcfs_device_userstate *ldu;
+	ENTRY;
 
-        ldu = (struct libcfs_device_userstate *)args;
-        if (ldu != NULL) {
-                kportal_memhog_free(ldu);
-                LIBCFS_FREE(ldu, sizeof(*ldu));
-        }
+	ldu = (struct libcfs_device_userstate *)args;
+	if (ldu != NULL) {
+		kportal_memhog_free(ldu);
+		LIBCFS_FREE(ldu, sizeof(*ldu));
+	}
 
-        PORTAL_MODULE_UNUSE;
-        RETURN(0);
+	module_put(THIS_MODULE);
+	RETURN(0);
 }
 
-static cfs_rw_semaphore_t ioctl_list_sem;
+static struct rw_semaphore ioctl_list_sem;
 static cfs_list_t ioctl_list;
 
 int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand)
 {
         int rc = 0;
 
-        cfs_down_write(&ioctl_list_sem);
+	down_write(&ioctl_list_sem);
         if (!cfs_list_empty(&hand->item))
                 rc = -EBUSY;
         else
                 cfs_list_add_tail(&hand->item, &ioctl_list);
-        cfs_up_write(&ioctl_list_sem);
+	up_write(&ioctl_list_sem);
 
         return rc;
 }
@@ -207,12 +206,12 @@ int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand)
 {
         int rc = 0;
 
-        cfs_down_write(&ioctl_list_sem);
+	down_write(&ioctl_list_sem);
         if (cfs_list_empty(&hand->item))
                 rc = -ENOENT;
         else
                 cfs_list_del_init(&hand->item);
-        cfs_up_write(&ioctl_list_sem);
+	up_write(&ioctl_list_sem);
 
         return rc;
 }
@@ -288,26 +287,26 @@ static int libcfs_ioctl_int(struct cfs_psdev_file *pfile,unsigned long cmd,
                 break;
 
         case IOC_LIBCFS_PING_TEST: {
-                extern void (kping_client)(struct libcfs_ioctl_data *);
-                void (*ping)(struct libcfs_ioctl_data *);
-
-                CDEBUG(D_IOCTL, "doing %d pings to nid %s (%s)\n",
-                       data->ioc_count, libcfs_nid2str(data->ioc_nid),
-                       libcfs_nid2str(data->ioc_nid));
-                ping = PORTAL_SYMBOL_GET(kping_client);
-                if (!ping)
-                        CERROR("PORTAL_SYMBOL_GET failed\n");
-                else {
-                        ping(data);
-                        PORTAL_SYMBOL_PUT(kping_client);
-                }
-                RETURN(0);
-        }
+		extern void (kping_client)(struct libcfs_ioctl_data *);
+		void (*ping)(struct libcfs_ioctl_data *);
+
+		CDEBUG(D_IOCTL, "doing %d pings to nid %s (%s)\n",
+		       data->ioc_count, libcfs_nid2str(data->ioc_nid),
+		       libcfs_nid2str(data->ioc_nid));
+		ping = symbol_get(kping_client);
+		if (!ping) {
+			CERROR("symbol_get failed\n");
+		} else {
+			ping(data);
+			symbol_put(kping_client);
+		}
+		RETURN(0);
+	}
 
         default: {
                 struct libcfs_ioctl_handler *hand;
                 err = -EINVAL;
-                cfs_down_read(&ioctl_list_sem);
+		down_read(&ioctl_list_sem);
                 cfs_list_for_each_entry_typed(hand, &ioctl_list,
                         struct libcfs_ioctl_handler, item) {
                         err = hand->handle_ioctl(cmd, data);
@@ -318,7 +317,7 @@ static int libcfs_ioctl_int(struct cfs_psdev_file *pfile,unsigned long cmd,
                                 break;
                         }
                 }
-                cfs_up_read(&ioctl_list_sem);
+		up_read(&ioctl_list_sem);
                 break;
         }
         }
@@ -326,16 +325,17 @@ static int libcfs_ioctl_int(struct cfs_psdev_file *pfile,unsigned long cmd,
         RETURN(err);
 }
 
-static int libcfs_ioctl(struct cfs_psdev_file *pfile, unsigned long cmd, void *arg)
+static int libcfs_ioctl(struct cfs_psdev_file *pfile,
+			unsigned long cmd, void *arg)
 {
-        char    *buf;
-        struct libcfs_ioctl_data *data;
-        int err = 0;
-        ENTRY;
+	char    *buf;
+	struct libcfs_ioctl_data *data;
+	int err = 0;
+	ENTRY;
 
-        LIBCFS_ALLOC_GFP(buf, 1024, CFS_ALLOC_STD);
-        if (buf == NULL)
-                RETURN(-ENOMEM);
+	LIBCFS_ALLOC_GFP(buf, 1024, GFP_IOFS);
+	if (buf == NULL)
+		RETURN(-ENOMEM);
 
         /* 'cmd' and permissions get checked in our arch-specific caller */
         if (libcfs_ioctl_getdata(buf, buf + 800, (void *)arg)) {
@@ -366,9 +366,10 @@ MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
 MODULE_DESCRIPTION("Portals v3.1");
 MODULE_LICENSE("GPL");
 
-extern cfs_psdev_t libcfs_dev;
-extern cfs_rw_semaphore_t cfs_tracefile_sem;
-extern cfs_mutex_t cfs_trace_thread_mutex;
+extern struct miscdevice libcfs_dev;
+extern struct rw_semaphore cfs_tracefile_sem;
+extern struct mutex cfs_trace_thread_mutex;
+extern struct cfs_wi_sched *cfs_sched_rehash;
 
 extern void libcfs_init_nidstrings(void);
 extern int libcfs_arch_init(void);
@@ -376,94 +377,123 @@ extern void libcfs_arch_cleanup(void);
 
 static int init_libcfs_module(void)
 {
-        int rc;
-
-        libcfs_arch_init();
-        libcfs_init_nidstrings();
-        cfs_init_rwsem(&cfs_tracefile_sem);
-        cfs_mutex_init(&cfs_trace_thread_mutex);
-        cfs_init_rwsem(&ioctl_list_sem);
-        CFS_INIT_LIST_HEAD(&ioctl_list);
-        cfs_waitq_init(&cfs_race_waitq);
-
-        rc = libcfs_debug_init(5 * 1024 * 1024);
-        if (rc < 0) {
-                printk(CFS_KERN_ERR "LustreError: libcfs_debug_init: %d\n", rc);
-                return (rc);
-        }
+	int rc;
+
+	libcfs_arch_init();
+	libcfs_init_nidstrings();
+	init_rwsem(&cfs_tracefile_sem);
+	mutex_init(&cfs_trace_thread_mutex);
+	init_rwsem(&ioctl_list_sem);
+	CFS_INIT_LIST_HEAD(&ioctl_list);
+	init_waitqueue_head(&cfs_race_waitq);
+
+	rc = libcfs_debug_init(5 * 1024 * 1024);
+	if (rc < 0) {
+		printk(KERN_ERR "LustreError: libcfs_debug_init: %d\n", rc);
+		return (rc);
+	}
+
+	rc = cfs_cpu_init();
+	if (rc != 0)
+		goto cleanup_debug;
 
 #if LWT_SUPPORT
-        rc = lwt_init();
-        if (rc != 0) {
-                CERROR("lwt_init: error %d\n", rc);
-                goto cleanup_debug;
-        }
+	rc = lwt_init();
+	if (rc != 0) {
+		CERROR("lwt_init: error %d\n", rc);
+		goto cleanup_debug;
+	}
 #endif
-        rc = cfs_psdev_register(&libcfs_dev);
-        if (rc) {
-                CERROR("misc_register: error %d\n", rc);
-                goto cleanup_lwt;
-        }
-
-        rc = cfs_wi_startup();
-        if (rc) {
-                CERROR("startup workitem: error %d\n", rc);
-                goto cleanup_deregister;
-        }
-
-        rc = insert_proc();
-        if (rc) {
-                CERROR("insert_proc: error %d\n", rc);
-                goto cleanup_wi;
-        }
-
-        CDEBUG (D_OTHER, "portals setup OK\n");
-        return (0);
-
+	rc = misc_register(&libcfs_dev);
+	if (rc) {
+		CERROR("misc_register: error %d\n", rc);
+		goto cleanup_lwt;
+	}
+
+	rc = cfs_wi_startup();
+	if (rc) {
+		CERROR("initialize workitem: error %d\n", rc);
+		goto cleanup_deregister;
+	}
+
+	/* max to 4 threads, should be enough for rehash */
+	rc = min(cfs_cpt_weight(cfs_cpt_table, CFS_CPT_ANY), 4);
+	rc = cfs_wi_sched_create("cfs_rh", cfs_cpt_table, CFS_CPT_ANY,
+				 rc, &cfs_sched_rehash);
+	if (rc != 0) {
+		CERROR("Startup workitem scheduler: error: %d\n", rc);
+		goto cleanup_deregister;
+	}
+
+	rc = cfs_crypto_register();
+	if (rc) {
+		CERROR("cfs_crypto_regster: error %d\n", rc);
+		goto cleanup_wi;
+	}
+
+
+	rc = insert_proc();
+	if (rc) {
+		CERROR("insert_proc: error %d\n", rc);
+		goto cleanup_crypto;
+	}
+
+	CDEBUG (D_OTHER, "portals setup OK\n");
+	return 0;
+ cleanup_crypto:
+	cfs_crypto_unregister();
  cleanup_wi:
-        cfs_wi_shutdown();
+	cfs_wi_shutdown();
  cleanup_deregister:
-        cfs_psdev_deregister(&libcfs_dev);
+	misc_deregister(&libcfs_dev);
  cleanup_lwt:
 #if LWT_SUPPORT
-        lwt_fini();
- cleanup_debug:
+	lwt_fini();
 #endif
-        libcfs_debug_cleanup();
-        return rc;
+ cleanup_debug:
+	libcfs_debug_cleanup();
+	return rc;
 }
 
 static void exit_libcfs_module(void)
 {
-        int rc;
+	int rc;
+
+	remove_proc();
+
+	CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n",
+	       cfs_atomic_read(&libcfs_kmemory));
 
-        remove_proc();
+	if (cfs_sched_rehash != NULL) {
+		cfs_wi_sched_destroy(cfs_sched_rehash);
+		cfs_sched_rehash = NULL;
+	}
 
-        CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n",
-               cfs_atomic_read(&libcfs_kmemory));
+	cfs_crypto_unregister();
+	cfs_wi_shutdown();
 
-        cfs_wi_shutdown();
-        rc = cfs_psdev_deregister(&libcfs_dev);
-        if (rc)
-                CERROR("misc_deregister error %d\n", rc);
+	rc = misc_deregister(&libcfs_dev);
+	if (rc)
+		CERROR("misc_deregister error %d\n", rc);
 
 #if LWT_SUPPORT
-        lwt_fini();
+	lwt_fini();
 #endif
+	cfs_cpu_fini();
 
-        if (cfs_atomic_read(&libcfs_kmemory) != 0)
-                CERROR("Portals memory leaked: %d bytes\n",
-                       cfs_atomic_read(&libcfs_kmemory));
+	if (cfs_atomic_read(&libcfs_kmemory) != 0)
+		CERROR("Portals memory leaked: %d bytes\n",
+		       cfs_atomic_read(&libcfs_kmemory));
 
-        rc = libcfs_debug_cleanup();
-        if (rc)
-                printk(CFS_KERN_ERR "LustreError: libcfs_debug_cleanup: %d\n",
-                       rc);
+	rc = libcfs_debug_cleanup();
+	if (rc)
+		printk(KERN_ERR "LustreError: libcfs_debug_cleanup: %d\n",
+		       rc);
 
-        cfs_fini_rwsem(&ioctl_list_sem);
-        cfs_fini_rwsem(&cfs_tracefile_sem);
+	fini_rwsem(&ioctl_list_sem);
+	fini_rwsem(&cfs_tracefile_sem);
 
-        libcfs_arch_cleanup();
+	libcfs_arch_cleanup();
 }
 
 cfs_module(libcfs, "1.0.0", init_libcfs_module, exit_libcfs_module);