David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 1 | /* AFS client file system |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
| 3 | * Copyright (C) 2002 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> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/completion.h> |
| 16 | #include <rxrpc/rxrpc.h> |
| 17 | #include <rxrpc/transport.h> |
| 18 | #include <rxrpc/call.h> |
| 19 | #include <rxrpc/peer.h> |
| 20 | #include "cache.h" |
| 21 | #include "cell.h" |
| 22 | #include "server.h" |
| 23 | #include "fsclient.h" |
| 24 | #include "cmservice.h" |
| 25 | #include "kafstimod.h" |
| 26 | #include "kafsasyncd.h" |
| 27 | #include "internal.h" |
| 28 | |
| 29 | struct rxrpc_transport *afs_transport; |
| 30 | |
| 31 | static int afs_adding_peer(struct rxrpc_peer *peer); |
| 32 | static void afs_discarding_peer(struct rxrpc_peer *peer); |
| 33 | |
| 34 | |
| 35 | MODULE_DESCRIPTION("AFS Client File System"); |
| 36 | MODULE_AUTHOR("Red Hat, Inc."); |
| 37 | MODULE_LICENSE("GPL"); |
| 38 | |
| 39 | static char *rootcell; |
| 40 | |
| 41 | module_param(rootcell, charp, 0); |
| 42 | MODULE_PARM_DESC(rootcell, "root AFS cell name and VL server IP addr list"); |
| 43 | |
| 44 | |
| 45 | static struct rxrpc_peer_ops afs_peer_ops = { |
| 46 | .adding = afs_adding_peer, |
| 47 | .discarding = afs_discarding_peer, |
| 48 | }; |
| 49 | |
| 50 | struct list_head afs_cb_hash_tbl[AFS_CB_HASH_COUNT]; |
| 51 | DEFINE_SPINLOCK(afs_cb_hash_lock); |
| 52 | |
| 53 | #ifdef AFS_CACHING_SUPPORT |
| 54 | static struct cachefs_netfs_operations afs_cache_ops = { |
| 55 | .get_page_cookie = afs_cache_get_page_cookie, |
| 56 | }; |
| 57 | |
| 58 | struct cachefs_netfs afs_cache_netfs = { |
| 59 | .name = "afs", |
| 60 | .version = 0, |
| 61 | .ops = &afs_cache_ops, |
| 62 | }; |
| 63 | #endif |
| 64 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | /* |
| 66 | * initialise the AFS client FS module |
| 67 | */ |
| 68 | static int __init afs_init(void) |
| 69 | { |
| 70 | int loop, ret; |
| 71 | |
| 72 | printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 registering.\n"); |
| 73 | |
| 74 | /* initialise the callback hash table */ |
| 75 | spin_lock_init(&afs_cb_hash_lock); |
| 76 | for (loop = AFS_CB_HASH_COUNT - 1; loop >= 0; loop--) |
| 77 | INIT_LIST_HEAD(&afs_cb_hash_tbl[loop]); |
| 78 | |
| 79 | /* register the /proc stuff */ |
| 80 | ret = afs_proc_init(); |
| 81 | if (ret < 0) |
| 82 | return ret; |
| 83 | |
| 84 | #ifdef AFS_CACHING_SUPPORT |
| 85 | /* we want to be able to cache */ |
| 86 | ret = cachefs_register_netfs(&afs_cache_netfs, |
| 87 | &afs_cache_cell_index_def); |
| 88 | if (ret < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | goto error_cache; |
| 90 | #endif |
| 91 | |
| 92 | /* initialise the cell DB */ |
| 93 | ret = afs_cell_init(rootcell); |
| 94 | if (ret < 0) |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 95 | goto error_cell_init; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | |
| 97 | /* start the timeout daemon */ |
| 98 | ret = afs_kafstimod_start(); |
| 99 | if (ret < 0) |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 100 | goto error_kafstimod; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | |
| 102 | /* start the async operation daemon */ |
| 103 | ret = afs_kafsasyncd_start(); |
| 104 | if (ret < 0) |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 105 | goto error_kafsasyncd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | |
| 107 | /* create the RxRPC transport */ |
| 108 | ret = rxrpc_create_transport(7001, &afs_transport); |
| 109 | if (ret < 0) |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 110 | goto error_transport; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | |
| 112 | afs_transport->peer_ops = &afs_peer_ops; |
| 113 | |
| 114 | /* register the filesystems */ |
| 115 | ret = afs_fs_init(); |
| 116 | if (ret < 0) |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 117 | goto error_fs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | |
| 119 | return ret; |
| 120 | |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 121 | error_fs: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | rxrpc_put_transport(afs_transport); |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 123 | error_transport: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | afs_kafsasyncd_stop(); |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 125 | error_kafsasyncd: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | afs_kafstimod_stop(); |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 127 | error_kafstimod: |
| 128 | error_cell_init: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | #ifdef AFS_CACHING_SUPPORT |
| 130 | cachefs_unregister_netfs(&afs_cache_netfs); |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 131 | error_cache: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | #endif |
| 133 | afs_cell_purge(); |
| 134 | afs_proc_cleanup(); |
| 135 | printk(KERN_ERR "kAFS: failed to register: %d\n", ret); |
| 136 | return ret; |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 137 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | |
| 139 | /* XXX late_initcall is kludgy, but the only alternative seems to create |
| 140 | * a transport upon the first mount, which is worse. Or is it? |
| 141 | */ |
| 142 | late_initcall(afs_init); /* must be called after net/ to create socket */ |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 143 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | /* |
| 145 | * clean up on module removal |
| 146 | */ |
| 147 | static void __exit afs_exit(void) |
| 148 | { |
| 149 | printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n"); |
| 150 | |
| 151 | afs_fs_exit(); |
| 152 | rxrpc_put_transport(afs_transport); |
| 153 | afs_kafstimod_stop(); |
| 154 | afs_kafsasyncd_stop(); |
| 155 | afs_cell_purge(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | #ifdef AFS_CACHING_SUPPORT |
| 157 | cachefs_unregister_netfs(&afs_cache_netfs); |
| 158 | #endif |
| 159 | afs_proc_cleanup(); |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 160 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | |
| 162 | module_exit(afs_exit); |
| 163 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | /* |
| 165 | * notification that new peer record is being added |
| 166 | * - called from krxsecd |
| 167 | * - return an error to induce an abort |
| 168 | * - mustn't sleep (caller holds an rwlock) |
| 169 | */ |
| 170 | static int afs_adding_peer(struct rxrpc_peer *peer) |
| 171 | { |
| 172 | struct afs_server *server; |
| 173 | int ret; |
| 174 | |
| 175 | _debug("kAFS: Adding new peer %08x\n", ntohl(peer->addr.s_addr)); |
| 176 | |
| 177 | /* determine which server the peer resides in (if any) */ |
| 178 | ret = afs_server_find_by_peer(peer, &server); |
| 179 | if (ret < 0) |
| 180 | return ret; /* none that we recognise, so abort */ |
| 181 | |
| 182 | _debug("Server %p{u=%d}\n", server, atomic_read(&server->usage)); |
| 183 | |
| 184 | _debug("Cell %p{u=%d}\n", |
| 185 | server->cell, atomic_read(&server->cell->usage)); |
| 186 | |
| 187 | /* cross-point the structs under a global lock */ |
| 188 | spin_lock(&afs_server_peer_lock); |
| 189 | peer->user = server; |
| 190 | server->peer = peer; |
| 191 | spin_unlock(&afs_server_peer_lock); |
| 192 | |
| 193 | afs_put_server(server); |
| 194 | |
| 195 | return 0; |
David Howells | ec26815 | 2007-04-26 15:49:28 -0700 | [diff] [blame^] | 196 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | /* |
| 199 | * notification that a peer record is being discarded |
| 200 | * - called from krxiod or krxsecd |
| 201 | */ |
| 202 | static void afs_discarding_peer(struct rxrpc_peer *peer) |
| 203 | { |
| 204 | struct afs_server *server; |
| 205 | |
| 206 | _enter("%p",peer); |
| 207 | |
| 208 | _debug("Discarding peer %08x (rtt=%lu.%lumS)\n", |
| 209 | ntohl(peer->addr.s_addr), |
| 210 | (long) (peer->rtt / 1000), |
| 211 | (long) (peer->rtt % 1000)); |
| 212 | |
| 213 | /* uncross-point the structs under a global lock */ |
| 214 | spin_lock(&afs_server_peer_lock); |
| 215 | server = peer->user; |
| 216 | if (server) { |
| 217 | peer->user = NULL; |
| 218 | server->peer = NULL; |
| 219 | } |
| 220 | spin_unlock(&afs_server_peer_lock); |
| 221 | |
| 222 | _leave(""); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | } |