After Al Viro (finally) succeeded in removing the sched.h #include in module.h recently, it makes sense again to remove other superfluous sched.h includes. There are quite a lot of files which include it but don't actually need anything defined in there. Presumably these includes were once needed for macros that used to live in sched.h, but moved to other header files in the course of cleaning it up. To ease the pain, this time I did not fiddle with any header files and only removed #includes from .c-files, which tend to cause less trouble. Compile tested against 2.6.20-rc2 and 2.6.20-rc2-mm2 (with offsets) on alpha, arm, i386, ia64, mips, powerpc, and x86_64 with allnoconfig, defconfig, allmodconfig, and allyesconfig as well as a few randconfigs on x86_64 and all configs in arch/arm/configs on arm. I also checked that no new warnings were introduced by the patch (actually, some warnings are removed that were emitted by unnecessarily included header files). Signed-off-by: Tim Schmielau <tim@physik3.uni-rostock.de> Acked-by: Russell King <rmk+kernel@arm.linux.org.uk> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
285 lines
7.5 KiB
C
285 lines
7.5 KiB
C
/* 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/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
|