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 #include <linux/proc_fs.h> 19 #define CREATE_TRACE_POINTS 20 #include "internal.h" 21 22 MODULE_DESCRIPTION("AFS Client File System"); 23 MODULE_AUTHOR("Red Hat, Inc."); 24 MODULE_LICENSE("GPL"); 25 26 unsigned afs_debug; 27 module_param_named(debug, afs_debug, uint, S_IWUSR | S_IRUGO); 28 MODULE_PARM_DESC(debug, "AFS debugging mask"); 29 30 static char *rootcell; 31 32 module_param(rootcell, charp, 0); 33 MODULE_PARM_DESC(rootcell, "root AFS cell name and VL server IP addr list"); 34 35 struct workqueue_struct *afs_wq; 36 static struct proc_dir_entry *afs_proc_symlink; 37 38 #if defined(CONFIG_ALPHA) 39 const char afs_init_sysname[] = "alpha_linux26"; 40 #elif defined(CONFIG_X86_64) 41 const char afs_init_sysname[] = "amd64_linux26"; 42 #elif defined(CONFIG_ARM) 43 const char afs_init_sysname[] = "arm_linux26"; 44 #elif defined(CONFIG_ARM64) 45 const char afs_init_sysname[] = "aarch64_linux26"; 46 #elif defined(CONFIG_X86_32) 47 const char afs_init_sysname[] = "i386_linux26"; 48 #elif defined(CONFIG_IA64) 49 const char afs_init_sysname[] = "ia64_linux26"; 50 #elif defined(CONFIG_PPC64) 51 const char afs_init_sysname[] = "ppc64_linux26"; 52 #elif defined(CONFIG_PPC32) 53 const char afs_init_sysname[] = "ppc_linux26"; 54 #elif defined(CONFIG_S390) 55 #ifdef CONFIG_64BIT 56 const char afs_init_sysname[] = "s390x_linux26"; 57 #else 58 const char afs_init_sysname[] = "s390_linux26"; 59 #endif 60 #elif defined(CONFIG_SPARC64) 61 const char afs_init_sysname[] = "sparc64_linux26"; 62 #elif defined(CONFIG_SPARC32) 63 const char afs_init_sysname[] = "sparc_linux26"; 64 #else 65 const char afs_init_sysname[] = "unknown_linux26"; 66 #endif 67 68 /* 69 * Initialise an AFS network namespace record. 70 */ 71 static int __net_init afs_net_init(struct net *net_ns) 72 { 73 struct afs_sysnames *sysnames; 74 struct afs_net *net = afs_net(net_ns); 75 int ret; 76 77 net->net = net_ns; 78 net->live = true; 79 generate_random_uuid((unsigned char *)&net->uuid); 80 81 INIT_WORK(&net->charge_preallocation_work, afs_charge_preallocation); 82 mutex_init(&net->socket_mutex); 83 84 net->cells = RB_ROOT; 85 seqlock_init(&net->cells_lock); 86 INIT_WORK(&net->cells_manager, afs_manage_cells); 87 timer_setup(&net->cells_timer, afs_cells_timer, 0); 88 89 mutex_init(&net->proc_cells_lock); 90 INIT_LIST_HEAD(&net->proc_cells); 91 92 seqlock_init(&net->fs_lock); 93 net->fs_servers = RB_ROOT; 94 INIT_LIST_HEAD(&net->fs_updates); 95 INIT_HLIST_HEAD(&net->fs_proc); 96 97 INIT_HLIST_HEAD(&net->fs_addresses4); 98 INIT_HLIST_HEAD(&net->fs_addresses6); 99 seqlock_init(&net->fs_addr_lock); 100 101 INIT_WORK(&net->fs_manager, afs_manage_servers); 102 timer_setup(&net->fs_timer, afs_servers_timer, 0); 103 104 ret = -ENOMEM; 105 sysnames = kzalloc(sizeof(*sysnames), GFP_KERNEL); 106 if (!sysnames) 107 goto error_sysnames; 108 sysnames->subs[0] = (char *)&afs_init_sysname; 109 sysnames->nr = 1; 110 refcount_set(&sysnames->usage, 1); 111 net->sysnames = sysnames; 112 rwlock_init(&net->sysnames_lock); 113 114 /* Register the /proc stuff */ 115 ret = afs_proc_init(net); 116 if (ret < 0) 117 goto error_proc; 118 119 /* Initialise the cell DB */ 120 ret = afs_cell_init(net, rootcell); 121 if (ret < 0) 122 goto error_cell_init; 123 124 /* Create the RxRPC transport */ 125 ret = afs_open_socket(net); 126 if (ret < 0) 127 goto error_open_socket; 128 129 return 0; 130 131 error_open_socket: 132 net->live = false; 133 afs_cell_purge(net); 134 afs_purge_servers(net); 135 error_cell_init: 136 net->live = false; 137 afs_proc_cleanup(net); 138 error_proc: 139 afs_put_sysnames(net->sysnames); 140 error_sysnames: 141 net->live = false; 142 return ret; 143 } 144 145 /* 146 * Clean up and destroy an AFS network namespace record. 147 */ 148 static void __net_exit afs_net_exit(struct net *net_ns) 149 { 150 struct afs_net *net = afs_net(net_ns); 151 152 net->live = false; 153 afs_cell_purge(net); 154 afs_purge_servers(net); 155 afs_close_socket(net); 156 afs_proc_cleanup(net); 157 afs_put_sysnames(net->sysnames); 158 } 159 160 static struct pernet_operations afs_net_ops = { 161 .init = afs_net_init, 162 .exit = afs_net_exit, 163 .id = &afs_net_id, 164 .size = sizeof(struct afs_net), 165 }; 166 167 /* 168 * initialise the AFS client FS module 169 */ 170 static int __init afs_init(void) 171 { 172 int ret = -ENOMEM; 173 174 printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 registering.\n"); 175 176 afs_wq = alloc_workqueue("afs", 0, 0); 177 if (!afs_wq) 178 goto error_afs_wq; 179 afs_async_calls = alloc_workqueue("kafsd", WQ_MEM_RECLAIM, 0); 180 if (!afs_async_calls) 181 goto error_async; 182 afs_lock_manager = alloc_workqueue("kafs_lockd", WQ_MEM_RECLAIM, 0); 183 if (!afs_lock_manager) 184 goto error_lockmgr; 185 186 #ifdef CONFIG_AFS_FSCACHE 187 /* we want to be able to cache */ 188 ret = fscache_register_netfs(&afs_cache_netfs); 189 if (ret < 0) 190 goto error_cache; 191 #endif 192 193 ret = register_pernet_subsys(&afs_net_ops); 194 if (ret < 0) 195 goto error_net; 196 197 /* register the filesystems */ 198 ret = afs_fs_init(); 199 if (ret < 0) 200 goto error_fs; 201 202 afs_proc_symlink = proc_symlink("fs/afs", NULL, "../self/net/afs"); 203 if (IS_ERR(afs_proc_symlink)) { 204 ret = PTR_ERR(afs_proc_symlink); 205 goto error_proc; 206 } 207 208 return ret; 209 210 error_proc: 211 afs_fs_exit(); 212 error_fs: 213 unregister_pernet_subsys(&afs_net_ops); 214 error_net: 215 #ifdef CONFIG_AFS_FSCACHE 216 fscache_unregister_netfs(&afs_cache_netfs); 217 error_cache: 218 #endif 219 destroy_workqueue(afs_lock_manager); 220 error_lockmgr: 221 destroy_workqueue(afs_async_calls); 222 error_async: 223 destroy_workqueue(afs_wq); 224 error_afs_wq: 225 rcu_barrier(); 226 printk(KERN_ERR "kAFS: failed to register: %d\n", ret); 227 return ret; 228 } 229 230 /* XXX late_initcall is kludgy, but the only alternative seems to create 231 * a transport upon the first mount, which is worse. Or is it? 232 */ 233 late_initcall(afs_init); /* must be called after net/ to create socket */ 234 235 /* 236 * clean up on module removal 237 */ 238 static void __exit afs_exit(void) 239 { 240 printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n"); 241 242 proc_remove(afs_proc_symlink); 243 afs_fs_exit(); 244 unregister_pernet_subsys(&afs_net_ops); 245 #ifdef CONFIG_AFS_FSCACHE 246 fscache_unregister_netfs(&afs_cache_netfs); 247 #endif 248 destroy_workqueue(afs_lock_manager); 249 destroy_workqueue(afs_async_calls); 250 destroy_workqueue(afs_wq); 251 afs_clean_up_permit_cache(); 252 rcu_barrier(); 253 } 254 255 module_exit(afs_exit); 256