Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
ec26815a | 2 | /* AFS client file system |
1da177e4 | 3 | * |
9b3f26c9 | 4 | * Copyright (C) 2002,5 Red Hat, Inc. All Rights Reserved. |
1da177e4 | 5 | * Written by David Howells (dhowells@redhat.com) |
1da177e4 LT |
6 | */ |
7 | ||
8 | #include <linux/module.h> | |
9 | #include <linux/moduleparam.h> | |
10 | #include <linux/init.h> | |
1da177e4 | 11 | #include <linux/completion.h> |
e8edc6e0 | 12 | #include <linux/sched.h> |
e0661dfc | 13 | #include <linux/random.h> |
5b86d4ff | 14 | #include <linux/proc_fs.h> |
8e8d7f13 | 15 | #define CREATE_TRACE_POINTS |
1da177e4 LT |
16 | #include "internal.h" |
17 | ||
1da177e4 LT |
18 | MODULE_DESCRIPTION("AFS Client File System"); |
19 | MODULE_AUTHOR("Red Hat, Inc."); | |
20 | MODULE_LICENSE("GPL"); | |
21 | ||
08e0e7c8 DH |
22 | unsigned afs_debug; |
23 | module_param_named(debug, afs_debug, uint, S_IWUSR | S_IRUGO); | |
424b00e2 | 24 | MODULE_PARM_DESC(debug, "AFS debugging mask"); |
08e0e7c8 | 25 | |
1da177e4 LT |
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 | ||
0ad53eee | 31 | struct workqueue_struct *afs_wq; |
5b86d4ff | 32 | static struct proc_dir_entry *afs_proc_symlink; |
f044c884 | 33 | |
6f8880d8 DH |
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"; | |
6f8880d8 DH |
44 | #elif defined(CONFIG_PPC64) |
45 | const char afs_init_sysname[] = "ppc64_linux26"; | |
46 | #elif defined(CONFIG_PPC32) | |
47 | const char afs_init_sysname[] = "ppc_linux26"; | |
48 | #elif defined(CONFIG_S390) | |
49 | #ifdef CONFIG_64BIT | |
50 | const char afs_init_sysname[] = "s390x_linux26"; | |
51 | #else | |
52 | const char afs_init_sysname[] = "s390_linux26"; | |
53 | #endif | |
54 | #elif defined(CONFIG_SPARC64) | |
55 | const char afs_init_sysname[] = "sparc64_linux26"; | |
56 | #elif defined(CONFIG_SPARC32) | |
57 | const char afs_init_sysname[] = "sparc_linux26"; | |
58 | #else | |
59 | const char afs_init_sysname[] = "unknown_linux26"; | |
60 | #endif | |
61 | ||
f044c884 DH |
62 | /* |
63 | * Initialise an AFS network namespace record. | |
64 | */ | |
5b86d4ff | 65 | static int __net_init afs_net_init(struct net *net_ns) |
f044c884 | 66 | { |
6f8880d8 | 67 | struct afs_sysnames *sysnames; |
5b86d4ff | 68 | struct afs_net *net = afs_net(net_ns); |
f044c884 DH |
69 | int ret; |
70 | ||
5b86d4ff | 71 | net->net = net_ns; |
f044c884 DH |
72 | net->live = true; |
73 | generate_random_uuid((unsigned char *)&net->uuid); | |
74 | ||
75 | INIT_WORK(&net->charge_preallocation_work, afs_charge_preallocation); | |
76 | mutex_init(&net->socket_mutex); | |
989782dc DH |
77 | |
78 | net->cells = RB_ROOT; | |
92e3cc91 | 79 | init_rwsem(&net->cells_lock); |
989782dc DH |
80 | INIT_WORK(&net->cells_manager, afs_manage_cells); |
81 | timer_setup(&net->cells_timer, afs_cells_timer, 0); | |
82 | ||
8a070a96 | 83 | mutex_init(&net->cells_alias_lock); |
0da0b7fd | 84 | mutex_init(&net->proc_cells_lock); |
6b3944e4 | 85 | INIT_HLIST_HEAD(&net->proc_cells); |
989782dc | 86 | |
d2ddc776 DH |
87 | seqlock_init(&net->fs_lock); |
88 | net->fs_servers = RB_ROOT; | |
f6cbb368 DH |
89 | INIT_LIST_HEAD(&net->fs_probe_fast); |
90 | INIT_LIST_HEAD(&net->fs_probe_slow); | |
d2ddc776 DH |
91 | INIT_HLIST_HEAD(&net->fs_proc); |
92 | ||
bfacaf71 | 93 | INIT_HLIST_HEAD(&net->fs_addresses); |
d2ddc776 DH |
94 | seqlock_init(&net->fs_addr_lock); |
95 | ||
96 | INIT_WORK(&net->fs_manager, afs_manage_servers); | |
97 | timer_setup(&net->fs_timer, afs_servers_timer, 0); | |
f6cbb368 DH |
98 | INIT_WORK(&net->fs_prober, afs_fs_probe_dispatcher); |
99 | timer_setup(&net->fs_probe_timer, afs_fs_probe_timer, 0); | |
5481fc6e | 100 | atomic_set(&net->servers_outstanding, 1); |
f044c884 | 101 | |
6f8880d8 DH |
102 | ret = -ENOMEM; |
103 | sysnames = kzalloc(sizeof(*sysnames), GFP_KERNEL); | |
104 | if (!sysnames) | |
105 | goto error_sysnames; | |
106 | sysnames->subs[0] = (char *)&afs_init_sysname; | |
107 | sysnames->nr = 1; | |
108 | refcount_set(&sysnames->usage, 1); | |
109 | net->sysnames = sysnames; | |
110 | rwlock_init(&net->sysnames_lock); | |
111 | ||
f044c884 DH |
112 | /* Register the /proc stuff */ |
113 | ret = afs_proc_init(net); | |
114 | if (ret < 0) | |
115 | goto error_proc; | |
116 | ||
117 | /* Initialise the cell DB */ | |
118 | ret = afs_cell_init(net, rootcell); | |
119 | if (ret < 0) | |
120 | goto error_cell_init; | |
121 | ||
122 | /* Create the RxRPC transport */ | |
123 | ret = afs_open_socket(net); | |
124 | if (ret < 0) | |
125 | goto error_open_socket; | |
126 | ||
127 | return 0; | |
128 | ||
129 | error_open_socket: | |
989782dc | 130 | net->live = false; |
5481fc6e | 131 | afs_fs_probe_cleanup(net); |
f044c884 | 132 | afs_cell_purge(net); |
d2ddc776 | 133 | afs_purge_servers(net); |
f044c884 | 134 | error_cell_init: |
989782dc | 135 | net->live = false; |
f044c884 DH |
136 | afs_proc_cleanup(net); |
137 | error_proc: | |
6f8880d8 DH |
138 | afs_put_sysnames(net->sysnames); |
139 | error_sysnames: | |
989782dc | 140 | net->live = false; |
f044c884 DH |
141 | return ret; |
142 | } | |
143 | ||
144 | /* | |
145 | * Clean up and destroy an AFS network namespace record. | |
146 | */ | |
5b86d4ff | 147 | static void __net_exit afs_net_exit(struct net *net_ns) |
f044c884 | 148 | { |
5b86d4ff DH |
149 | struct afs_net *net = afs_net(net_ns); |
150 | ||
f044c884 | 151 | net->live = false; |
5481fc6e | 152 | afs_fs_probe_cleanup(net); |
f044c884 | 153 | afs_cell_purge(net); |
d2ddc776 | 154 | afs_purge_servers(net); |
e3b2ffe0 | 155 | afs_close_socket(net); |
f044c884 | 156 | afs_proc_cleanup(net); |
6f8880d8 | 157 | afs_put_sysnames(net->sysnames); |
f94f70d3 | 158 | kfree_rcu(rcu_access_pointer(net->address_prefs), rcu); |
f044c884 | 159 | } |
b908fe6b | 160 | |
5b86d4ff DH |
161 | static struct pernet_operations afs_net_ops = { |
162 | .init = afs_net_init, | |
163 | .exit = afs_net_exit, | |
164 | .id = &afs_net_id, | |
165 | .size = sizeof(struct afs_net), | |
166 | }; | |
167 | ||
1da177e4 LT |
168 | /* |
169 | * initialise the AFS client FS module | |
170 | */ | |
171 | static int __init afs_init(void) | |
172 | { | |
f044c884 | 173 | int ret = -ENOMEM; |
1da177e4 LT |
174 | |
175 | printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 registering.\n"); | |
176 | ||
0ad53eee TH |
177 | afs_wq = alloc_workqueue("afs", 0, 0); |
178 | if (!afs_wq) | |
f044c884 DH |
179 | goto error_afs_wq; |
180 | afs_async_calls = alloc_workqueue("kafsd", WQ_MEM_RECLAIM, 0); | |
181 | if (!afs_async_calls) | |
182 | goto error_async; | |
f044c884 DH |
183 | afs_lock_manager = alloc_workqueue("kafs_lockd", WQ_MEM_RECLAIM, 0); |
184 | if (!afs_lock_manager) | |
185 | goto error_lockmgr; | |
1da177e4 | 186 | |
5399d522 | 187 | ret = register_pernet_device(&afs_net_ops); |
df44f9f4 | 188 | if (ret < 0) |
f044c884 | 189 | goto error_net; |
1da177e4 LT |
190 | |
191 | /* register the filesystems */ | |
192 | ret = afs_fs_init(); | |
193 | if (ret < 0) | |
ec26815a | 194 | goto error_fs; |
1da177e4 | 195 | |
5b86d4ff | 196 | afs_proc_symlink = proc_symlink("fs/afs", NULL, "../self/net/afs"); |
a33d6266 DC |
197 | if (!afs_proc_symlink) { |
198 | ret = -ENOMEM; | |
5b86d4ff DH |
199 | goto error_proc; |
200 | } | |
201 | ||
1da177e4 LT |
202 | return ret; |
203 | ||
5b86d4ff DH |
204 | error_proc: |
205 | afs_fs_exit(); | |
ec26815a | 206 | error_fs: |
5399d522 | 207 | unregister_pernet_device(&afs_net_ops); |
f044c884 | 208 | error_net: |
f044c884 DH |
209 | destroy_workqueue(afs_lock_manager); |
210 | error_lockmgr: | |
f044c884 DH |
211 | destroy_workqueue(afs_async_calls); |
212 | error_async: | |
0ad53eee | 213 | destroy_workqueue(afs_wq); |
f044c884 | 214 | error_afs_wq: |
416351f2 | 215 | rcu_barrier(); |
1da177e4 LT |
216 | printk(KERN_ERR "kAFS: failed to register: %d\n", ret); |
217 | return ret; | |
ec26815a | 218 | } |
1da177e4 LT |
219 | |
220 | /* XXX late_initcall is kludgy, but the only alternative seems to create | |
221 | * a transport upon the first mount, which is worse. Or is it? | |
222 | */ | |
223 | late_initcall(afs_init); /* must be called after net/ to create socket */ | |
ec26815a | 224 | |
1da177e4 LT |
225 | /* |
226 | * clean up on module removal | |
227 | */ | |
228 | static void __exit afs_exit(void) | |
229 | { | |
230 | printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n"); | |
231 | ||
5b86d4ff | 232 | proc_remove(afs_proc_symlink); |
1da177e4 | 233 | afs_fs_exit(); |
5399d522 | 234 | unregister_pernet_device(&afs_net_ops); |
f044c884 | 235 | destroy_workqueue(afs_lock_manager); |
f044c884 DH |
236 | destroy_workqueue(afs_async_calls); |
237 | destroy_workqueue(afs_wq); | |
be080a6f | 238 | afs_clean_up_permit_cache(); |
416351f2 | 239 | rcu_barrier(); |
ec26815a | 240 | } |
1da177e4 LT |
241 | |
242 | module_exit(afs_exit); |