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