1 /* AFS client file system 2 * 3 * Copyright (C) 2002,5 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 #include <linux/module.h> 13 #include <linux/moduleparam.h> 14 #include <linux/init.h> 15 #include <linux/completion.h> 16 #include <linux/sched.h> 17 #include <linux/random.h> 18 #define CREATE_TRACE_POINTS 19 #include "internal.h" 20 21 MODULE_DESCRIPTION("AFS Client File System"); 22 MODULE_AUTHOR("Red Hat, Inc."); 23 MODULE_LICENSE("GPL"); 24 25 unsigned afs_debug; 26 module_param_named(debug, afs_debug, uint, S_IWUSR | S_IRUGO); 27 MODULE_PARM_DESC(debug, "AFS debugging mask"); 28 29 static char *rootcell; 30 31 module_param(rootcell, charp, 0); 32 MODULE_PARM_DESC(rootcell, "root AFS cell name and VL server IP addr list"); 33 34 struct workqueue_struct *afs_wq; 35 struct afs_net __afs_net; 36 37 /* 38 * Initialise an AFS network namespace record. 39 */ 40 static int __net_init afs_net_init(struct afs_net *net) 41 { 42 int ret; 43 44 net->live = true; 45 generate_random_uuid((unsigned char *)&net->uuid); 46 47 INIT_WORK(&net->charge_preallocation_work, afs_charge_preallocation); 48 mutex_init(&net->socket_mutex); 49 INIT_LIST_HEAD(&net->cells); 50 rwlock_init(&net->cells_lock); 51 init_rwsem(&net->cells_sem); 52 init_waitqueue_head(&net->cells_freeable_wq); 53 init_rwsem(&net->proc_cells_sem); 54 INIT_LIST_HEAD(&net->proc_cells); 55 INIT_LIST_HEAD(&net->vl_updates); 56 INIT_LIST_HEAD(&net->vl_graveyard); 57 INIT_DELAYED_WORK(&net->vl_reaper, afs_vlocation_reaper); 58 INIT_DELAYED_WORK(&net->vl_updater, afs_vlocation_updater); 59 spin_lock_init(&net->vl_updates_lock); 60 spin_lock_init(&net->vl_graveyard_lock); 61 net->servers = RB_ROOT; 62 rwlock_init(&net->servers_lock); 63 INIT_LIST_HEAD(&net->server_graveyard); 64 spin_lock_init(&net->server_graveyard_lock); 65 INIT_WORK(&net->server_reaper, afs_reap_server); 66 timer_setup(&net->server_timer, afs_server_timer, 0); 67 68 /* Register the /proc stuff */ 69 ret = afs_proc_init(net); 70 if (ret < 0) 71 goto error_proc; 72 73 /* Initialise the cell DB */ 74 ret = afs_cell_init(net, rootcell); 75 if (ret < 0) 76 goto error_cell_init; 77 78 /* Create the RxRPC transport */ 79 ret = afs_open_socket(net); 80 if (ret < 0) 81 goto error_open_socket; 82 83 return 0; 84 85 error_open_socket: 86 afs_vlocation_purge(net); 87 afs_cell_purge(net); 88 error_cell_init: 89 afs_proc_cleanup(net); 90 error_proc: 91 return ret; 92 } 93 94 /* 95 * Clean up and destroy an AFS network namespace record. 96 */ 97 static void __net_exit afs_net_exit(struct afs_net *net) 98 { 99 net->live = false; 100 afs_purge_servers(net); 101 afs_vlocation_purge(net); 102 afs_cell_purge(net); 103 afs_close_socket(net); 104 afs_proc_cleanup(net); 105 } 106 107 /* 108 * initialise the AFS client FS module 109 */ 110 static int __init afs_init(void) 111 { 112 int ret = -ENOMEM; 113 114 printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 registering.\n"); 115 116 afs_wq = alloc_workqueue("afs", 0, 0); 117 if (!afs_wq) 118 goto error_afs_wq; 119 afs_async_calls = alloc_workqueue("kafsd", WQ_MEM_RECLAIM, 0); 120 if (!afs_async_calls) 121 goto error_async; 122 afs_vlocation_update_worker = 123 alloc_workqueue("kafs_vlupdated", WQ_MEM_RECLAIM, 0); 124 if (!afs_vlocation_update_worker) 125 goto error_vl_up; 126 afs_lock_manager = alloc_workqueue("kafs_lockd", WQ_MEM_RECLAIM, 0); 127 if (!afs_lock_manager) 128 goto error_lockmgr; 129 130 #ifdef CONFIG_AFS_FSCACHE 131 /* we want to be able to cache */ 132 ret = fscache_register_netfs(&afs_cache_netfs); 133 if (ret < 0) 134 goto error_cache; 135 #endif 136 137 ret = afs_net_init(&__afs_net); 138 if (ret < 0) 139 goto error_net; 140 141 /* register the filesystems */ 142 ret = afs_fs_init(); 143 if (ret < 0) 144 goto error_fs; 145 146 return ret; 147 148 error_fs: 149 afs_net_exit(&__afs_net); 150 error_net: 151 #ifdef CONFIG_AFS_FSCACHE 152 fscache_unregister_netfs(&afs_cache_netfs); 153 error_cache: 154 #endif 155 destroy_workqueue(afs_lock_manager); 156 error_lockmgr: 157 destroy_workqueue(afs_vlocation_update_worker); 158 error_vl_up: 159 destroy_workqueue(afs_async_calls); 160 error_async: 161 destroy_workqueue(afs_wq); 162 error_afs_wq: 163 rcu_barrier(); 164 printk(KERN_ERR "kAFS: failed to register: %d\n", ret); 165 return ret; 166 } 167 168 /* XXX late_initcall is kludgy, but the only alternative seems to create 169 * a transport upon the first mount, which is worse. Or is it? 170 */ 171 late_initcall(afs_init); /* must be called after net/ to create socket */ 172 173 /* 174 * clean up on module removal 175 */ 176 static void __exit afs_exit(void) 177 { 178 printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n"); 179 180 afs_fs_exit(); 181 afs_net_exit(&__afs_net); 182 #ifdef CONFIG_AFS_FSCACHE 183 fscache_unregister_netfs(&afs_cache_netfs); 184 #endif 185 destroy_workqueue(afs_lock_manager); 186 destroy_workqueue(afs_vlocation_update_worker); 187 destroy_workqueue(afs_async_calls); 188 destroy_workqueue(afs_wq); 189 rcu_barrier(); 190 } 191 192 module_exit(afs_exit); 193