fs/fscache/main.c

   1 /* General filesystem local caching manager
   2  *
   3  * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #define FSCACHE_DEBUG_LEVEL CACHE
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/sched.h>
  16 #include <linux/completion.h>
  17 #include <linux/slab.h>
  18 #include "internal.h"
  19
  20 MODULE_DESCRIPTION("FS Cache Manager");
  21 MODULE_AUTHOR("Red Hat, Inc.");
  22 MODULE_LICENSE("GPL");
  23
  24 unsigned fscache_defer_lookup = 1;
  25 module_param_named(defer_lookup, fscache_defer_lookup, uint,
  26                    S_IWUSR | S_IRUGO);
  27 MODULE_PARM_DESC(fscache_defer_lookup,
  28                  "Defer cookie lookup to background thread");
  29
  30 unsigned fscache_defer_create = 1;
  31 module_param_named(defer_create, fscache_defer_create, uint,
  32                    S_IWUSR | S_IRUGO);
  33 MODULE_PARM_DESC(fscache_defer_create,
  34                  "Defer cookie creation to background thread");
  35
  36 unsigned fscache_debug;
  37 module_param_named(debug, fscache_debug, uint,
  38                    S_IWUSR | S_IRUGO);
  39 MODULE_PARM_DESC(fscache_debug,
  40                  "FS-Cache debugging mask");
  41
  42 struct kobject *fscache_root;
  43
  44 /*
  45  * initialise the fs caching module
  46  */
  47 static int __init fscache_init(void)
  48 {
  49         int ret;
  50
  51         ret = slow_work_register_user(THIS_MODULE);
  52         if (ret < 0)
  53                 goto error_slow_work;
  54
  55         ret = fscache_proc_init();
  56         if (ret < 0)
  57                 goto error_proc;
  58
  59         fscache_cookie_jar = kmem_cache_create("fscache_cookie_jar",
  60                                                sizeof(struct fscache_cookie),
  61                                                0,
  62                                                0,
  63                                                fscache_cookie_init_once);
  64         if (!fscache_cookie_jar) {
  65                 printk(KERN_NOTICE
  66                        "FS-Cache: Failed to allocate a cookie jar\n");
  67                 ret = -ENOMEM;
  68                 goto error_cookie_jar;
  69         }
  70
  71         fscache_root = kobject_create_and_add("fscache", kernel_kobj);
  72         if (!fscache_root)
  73                 goto error_kobj;
  74
  75         printk(KERN_NOTICE "FS-Cache: Loaded\n");
  76         return 0;
  77
  78 error_kobj:
  79         kmem_cache_destroy(fscache_cookie_jar);
  80 error_cookie_jar:
  81         fscache_proc_cleanup();
  82 error_proc:
  83         slow_work_unregister_user(THIS_MODULE);
  84 error_slow_work:
  85         return ret;
  86 }
  87
  88 fs_initcall(fscache_init);
  89
  90 /*
  91  * clean up on module removal
  92  */
  93 static void __exit fscache_exit(void)
  94 {
  95         _enter("");
  96
  97         kobject_put(fscache_root);
  98         kmem_cache_destroy(fscache_cookie_jar);
  99         fscache_proc_cleanup();
 100         slow_work_unregister_user(THIS_MODULE);
 101         printk(KERN_NOTICE "FS-Cache: Unloaded\n");
 102 }
 103
 104 module_exit(fscache_exit);
 105
 106 /*
 107  * wait_on_bit() sleep function for uninterruptible waiting
 108  */
 109 int fscache_wait_bit(void *flags)
 110 {
 111         schedule();
 112         return 0;
 113 }
 114 EXPORT_SYMBOL(fscache_wait_bit);
 115
 116 /*
 117  * wait_on_bit() sleep function for interruptible waiting
 118  */
 119 int fscache_wait_bit_interruptible(void *flags)
 120 {
 121         schedule();
 122         return signal_pending(current);
 123 }
 124 EXPORT_SYMBOL(fscache_wait_bit_interruptible);