/* main.c: AFS client file system * * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/init.h> #include <linux/sched.h> #include <linux/completion.h> #include <rxrpc/rxrpc.h> #include <rxrpc/transport.h> #include <rxrpc/call.h> #include <rxrpc/peer.h> #include "cache.h" #include "cell.h" #include "server.h" #include "fsclient.h" #include "cmservice.h" #include "kafstimod.h" #include "kafsasyncd.h" #include "internal.h" struct rxrpc_transport *afs_transport; static int afs_adding_peer(struct rxrpc_peer *peer); static void afs_discarding_peer(struct rxrpc_peer *peer); MODULE_DESCRIPTION("AFS Client File System"); MODULE_AUTHOR("Red Hat, Inc."); MODULE_LICENSE("GPL"); static char *rootcell; module_param(rootcell, charp, 0); MODULE_PARM_DESC(rootcell, "root AFS cell name and VL server IP addr list"); static struct rxrpc_peer_ops afs_peer_ops = { .adding = afs_adding_peer, .discarding = afs_discarding_peer, }; struct list_head afs_cb_hash_tbl[AFS_CB_HASH_COUNT]; DEFINE_SPINLOCK(afs_cb_hash_lock); #ifdef AFS_CACHING_SUPPORT static struct cachefs_netfs_operations afs_cache_ops = { .get_page_cookie = afs_cache_get_page_cookie, }; struct cachefs_netfs afs_cache_netfs = { .name = "afs", .version = 0, .ops = &afs_cache_ops, }; #endif /*****************************************************************************/ /* * initialise the AFS client FS module */ static int __init afs_init(void) { int loop, ret; printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 registering.\n"); /* initialise the callback hash table */ spin_lock_init(&afs_cb_hash_lock); for (loop = AFS_CB_HASH_COUNT - 1; loop >= 0; loop--) INIT_LIST_HEAD(&afs_cb_hash_tbl[loop]); /* register the /proc stuff */ ret = afs_proc_init(); if (ret < 0) return ret; #ifdef AFS_CACHING_SUPPORT /* we want to be able to cache */ ret = cachefs_register_netfs(&afs_cache_netfs, &afs_cache_cell_index_def); if (ret < 0) goto error; #endif #ifdef CONFIG_KEYS_TURNED_OFF ret = afs_key_register(); if (ret < 0) goto error_cache; #endif /* initialise the cell DB */ ret = afs_cell_init(rootcell); if (ret < 0) goto error_keys; /* start the timeout daemon */ ret = afs_kafstimod_start(); if (ret < 0) goto error_keys; /* start the async operation daemon */ ret = afs_kafsasyncd_start(); if (ret < 0) goto error_kafstimod; /* create the RxRPC transport */ ret = rxrpc_create_transport(7001, &afs_transport); if (ret < 0) goto error_kafsasyncd; afs_transport->peer_ops = &afs_peer_ops; /* register the filesystems */ ret = afs_fs_init(); if (ret < 0) goto error_transport; return ret; error_transport: rxrpc_put_transport(afs_transport); error_kafsasyncd: afs_kafsasyncd_stop(); error_kafstimod: afs_kafstimod_stop(); error_keys: #ifdef CONFIG_KEYS_TURNED_OFF afs_key_unregister(); error_cache: #endif #ifdef AFS_CACHING_SUPPORT cachefs_unregister_netfs(&afs_cache_netfs); error: #endif afs_cell_purge(); afs_proc_cleanup(); printk(KERN_ERR "kAFS: failed to register: %d\n", ret); return ret; } /* end afs_init() */ /* XXX late_initcall is kludgy, but the only alternative seems to create * a transport upon the first mount, which is worse. Or is it? */ late_initcall(afs_init); /* must be called after net/ to create socket */ /*****************************************************************************/ /* * clean up on module removal */ static void __exit afs_exit(void) { printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n"); afs_fs_exit(); rxrpc_put_transport(afs_transport); afs_kafstimod_stop(); afs_kafsasyncd_stop(); afs_cell_purge(); #ifdef CONFIG_KEYS_TURNED_OFF afs_key_unregister(); #endif #ifdef AFS_CACHING_SUPPORT cachefs_unregister_netfs(&afs_cache_netfs); #endif afs_proc_cleanup(); } /* end afs_exit() */ module_exit(afs_exit); /*****************************************************************************/ /* * notification that new peer record is being added * - called from krxsecd * - return an error to induce an abort * - mustn't sleep (caller holds an rwlock) */ static int afs_adding_peer(struct rxrpc_peer *peer) { struct afs_server *server; int ret; _debug("kAFS: Adding new peer %08x\n", ntohl(peer->addr.s_addr)); /* determine which server the peer resides in (if any) */ ret = afs_server_find_by_peer(peer, &server); if (ret < 0) return ret; /* none that we recognise, so abort */ _debug("Server %p{u=%d}\n", server, atomic_read(&server->usage)); _debug("Cell %p{u=%d}\n", server->cell, atomic_read(&server->cell->usage)); /* cross-point the structs under a global lock */ spin_lock(&afs_server_peer_lock); peer->user = server; server->peer = peer; spin_unlock(&afs_server_peer_lock); afs_put_server(server); return 0; } /* end afs_adding_peer() */ /*****************************************************************************/ /* * notification that a peer record is being discarded * - called from krxiod or krxsecd */ static void afs_discarding_peer(struct rxrpc_peer *peer) { struct afs_server *server; _enter("%p",peer); _debug("Discarding peer %08x (rtt=%lu.%lumS)\n", ntohl(peer->addr.s_addr), (long) (peer->rtt / 1000), (long) (peer->rtt % 1000)); /* uncross-point the structs under a global lock */ spin_lock(&afs_server_peer_lock); server = peer->user; if (server) { peer->user = NULL; server->peer = NULL; } spin_unlock(&afs_server_peer_lock); _leave(""); } /* end afs_discarding_peer() */ /*****************************************************************************/ /* * clear the dead space between task_struct and kernel stack * - called by supplying -finstrument-functions to gcc */ #if 0 void __cyg_profile_func_enter (void *this_fn, void *call_site) __attribute__((no_instrument_function)); void __cyg_profile_func_enter (void *this_fn, void *call_site) { asm volatile(" movl %%esp,%%edi \n" " andl %0,%%edi \n" " addl %1,%%edi \n" " movl %%esp,%%ecx \n" " subl %%edi,%%ecx \n" " shrl $2,%%ecx \n" " movl $0xedededed,%%eax \n" " rep stosl \n" : : "i"(~(THREAD_SIZE - 1)), "i"(sizeof(struct thread_info)) : "eax", "ecx", "edi", "memory", "cc" ); } void __cyg_profile_func_exit(void *this_fn, void *call_site) __attribute__((no_instrument_function)); void __cyg_profile_func_exit(void *this_fn, void *call_site) { asm volatile(" movl %%esp,%%edi \n" " andl %0,%%edi \n" " addl %1,%%edi \n" " movl %%esp,%%ecx \n" " subl %%edi,%%ecx \n" " shrl $2,%%ecx \n" " movl $0xdadadada,%%eax \n" " rep stosl \n" : : "i"(~(THREAD_SIZE - 1)), "i"(sizeof(struct thread_info)) : "eax", "ecx", "edi", "memory", "cc" ); } #endif