[AFS]: Clean up the AFS sources (ec26815a) · Commits · 戴 / test

fs/afs/Makefile

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -2,8 +2,6 @@
	# Makefile for Red Hat Linux AFS client.		# Makefile for Red Hat Linux AFS client.
	#		#

	#CFLAGS += -finstrument-functions

	kafs-objs := \		kafs-objs := \
	callback.o \		callback.o \
	cell.o \		cell.o \

fs/afs/cache.h

+4 −8

Original line number	Original line	Diff line number	Diff line
	/* cache.h: AFS local cache management interface		/* AFS local cache management interface
	*		*
	* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.		* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
	* Written by David Howells (dhowells@redhat.com)		* Written by David Howells (dhowells@redhat.com)
	@@ -9,8 +9,8 @@
	* 2 of the License, or (at your option) any later version.		* 2 of the License, or (at your option) any later version.
	*/		*/

	#ifndef _LINUX_AFS_CACHE_H		#ifndef AFS_CACHE_H
	#define _LINUX_AFS_CACHE_H		#define AFS_CACHE_H

	#undef AFS_CACHING_SUPPORT		#undef AFS_CACHING_SUPPORT

	@@ -20,8 +20,4 @@
	#endif		#endif
	#include "types.h"		#include "types.h"

	#ifdef __KERNEL__		#endif /* AFS_CACHE_H */

	#endif /* __KERNEL__ */

	#endif /* _LINUX_AFS_CACHE_H */

fs/afs/callback.c

+3 −6

Original line number	Original line	Diff line number	Diff line
	@@ -21,7 +21,6 @@
	#include "internal.h"		#include "internal.h"
	#include "cmservice.h"		#include "cmservice.h"

	/*****************************************************************************/
	/*		/*
	* allow the fileserver to request callback state (re-)initialisation		* allow the fileserver to request callback state (re-)initialisation
	*/		*/
	@@ -79,9 +78,8 @@ int SRXAFSCM_InitCallBackState(struct afs_server *server)

	_leave(" = 0");		_leave(" = 0");
	return 0;		return 0;
	} /* end SRXAFSCM_InitCallBackState() */		}

	/*****************************************************************************/
	/*		/*
	* allow the fileserver to break callback promises		* allow the fileserver to break callback promises
	*/		*/
	@@ -156,9 +154,8 @@ int SRXAFSCM_CallBack(struct afs_server *server, size_t count,

	_leave(" = 0");		_leave(" = 0");
	return 0;		return 0;
	} /* end SRXAFSCM_CallBack() */		}

	/*****************************************************************************/
	/*		/*
	* allow the fileserver to see if the cache manager is still alive		* allow the fileserver to see if the cache manager is still alive
	*/		*/
	@@ -166,4 +163,4 @@ int SRXAFSCM_Probe(struct afs_server *server)
	{		{
	_debug("SRXAFSCM_Probe(%p)\n", server);		_debug("SRXAFSCM_Probe(%p)\n", server);
	return 0;		return 0;
	} /* end SRXAFSCM_Probe() */		}

fs/afs/cell.c

+18 −33

Original line number	Original line	Diff line number	Diff line
	/* cell.c: AFS cell and server record management		/* AFS cell and server record management
	*		*
	* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.		* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
	* Written by David Howells (dhowells@redhat.com)		* Written by David Howells (dhowells@redhat.com)
	@@ -44,7 +44,6 @@ struct cachefs_index_def afs_cache_cell_index_def = {
	};		};
	#endif		#endif

	/*****************************************************************************/
	/*		/*
	* create a cell record		* create a cell record
	* - "name" is the name of the cell		* - "name" is the name of the cell
	@@ -144,9 +143,8 @@ int afs_cell_create(const char name, char vllist, struct afs_cell **_cell)
	kfree(cell);		kfree(cell);
	_leave(" = %d", ret);		_leave(" = %d", ret);
	return ret;		return ret;
	} /* end afs_cell_create() */		}

	/*****************************************************************************/
	/*		/*
	* initialise the cell database from module parameters		* initialise the cell database from module parameters
	*/		*/
	@@ -199,10 +197,8 @@ int afs_cell_init(char *rootcell)

	_leave(" = %d", ret);		_leave(" = %d", ret);
	return ret;		return ret;
			}

	} /* end afs_cell_init() */

	/*****************************************************************************/
	/*		/*
	* lookup a cell record		* lookup a cell record
	*/		*/
	@@ -234,8 +230,7 @@ int afs_cell_lookup(const char name, unsigned namesz, struct afs_cell *_cell)

	if (cell)		if (cell)
	ret = 0;		ret = 0;
	}		} else {
	else {
	read_lock(&afs_cells_lock);		read_lock(&afs_cells_lock);

	cell = afs_cell_root;		cell = afs_cell_root;
	@@ -247,8 +242,7 @@ int afs_cell_lookup(const char name, unsigned namesz, struct afs_cell *_cell)
	* for other reasons.		* for other reasons.
	*/		*/
	ret = -EDESTADDRREQ;		ret = -EDESTADDRREQ;
	}		} else {
	else {
	afs_get_cell(cell);		afs_get_cell(cell);
	ret = 0;		ret = 0;
	}		}
	@@ -259,10 +253,8 @@ int afs_cell_lookup(const char name, unsigned namesz, struct afs_cell *_cell)
	*_cell = cell;		*_cell = cell;
	_leave(" = %d (%p)", ret, cell);		_leave(" = %d (%p)", ret, cell);
	return ret;		return ret;
			}

	} /* end afs_cell_lookup() */

	/*****************************************************************************/
	/*		/*
	* try and get a cell record		* try and get a cell record
	*/		*/
	@@ -281,9 +273,8 @@ struct afs_cell afs_get_cell_maybe(struct afs_cell *_cell)
	write_unlock(&afs_cells_lock);		write_unlock(&afs_cells_lock);

	return cell;		return cell;
	} /* end afs_get_cell_maybe() */		}

	/*****************************************************************************/
	/*		/*
	* destroy a cell record		* destroy a cell record
	*/		*/
	@@ -315,9 +306,8 @@ void afs_put_cell(struct afs_cell *cell)
	BUG_ON(!list_empty(&cell->vl_graveyard));		BUG_ON(!list_empty(&cell->vl_graveyard));

	_leave(" [unused]");		_leave(" [unused]");
	} /* end afs_put_cell() */		}

	/*****************************************************************************/
	/*		/*
	* destroy a cell record		* destroy a cell record
	*/		*/
	@@ -359,9 +349,8 @@ static void afs_cell_destroy(struct afs_cell *cell)
	kfree(cell);		kfree(cell);

	_leave(" [destroyed]");		_leave(" [destroyed]");
	} /* end afs_cell_destroy() */		}

	/*****************************************************************************/
	/*		/*
	* lookup the server record corresponding to an Rx RPC peer		* lookup the server record corresponding to an Rx RPC peer
	*/		*/
	@@ -429,10 +418,8 @@ int afs_server_find_by_peer(const struct rxrpc_peer *peer,
	*_server = server;		*_server = server;
	_leave(" = 0 (s=%p c=%p)", server, cell);		_leave(" = 0 (s=%p c=%p)", server, cell);
	return 0;		return 0;
			}

	} /* end afs_server_find_by_peer() */

	/*****************************************************************************/
	/*		/*
	* purge in-memory cell database on module unload or afs_init() failure		* purge in-memory cell database on module unload or afs_init() failure
	* - the timeout daemon is stopped before calling this		* - the timeout daemon is stopped before calling this
	@@ -520,9 +507,8 @@ void afs_cell_purge(void)
	}		}

	_leave("");		_leave("");
	} /* end afs_cell_purge() */		}

	/*****************************************************************************/
	/*		/*
	* match a cell record obtained from the cache		* match a cell record obtained from the cache
	*/		*/
	@@ -542,10 +528,9 @@ static cachefs_match_val_t afs_cell_cache_match(void *target,

	_leave(" = FAILED");		_leave(" = FAILED");
	return CACHEFS_MATCH_FAILED;		return CACHEFS_MATCH_FAILED;
	} /* end afs_cell_cache_match() */		}
	#endif		#endif

	/*****************************************************************************/
	/*		/*
	* update a cell record in the cache		* update a cell record in the cache
	*/		*/
	@@ -563,5 +548,5 @@ static void afs_cell_cache_update(void source, void entry)
	cell->vl_addrs,		cell->vl_addrs,
	min(sizeof(ccell->vl_servers), sizeof(cell->vl_addrs)));		min(sizeof(ccell->vl_servers), sizeof(cell->vl_addrs)));

	} /* end afs_cell_cache_update() */		}
	#endif		#endif

fs/afs/cell.h

+11 −19

Original line number	Original line	Diff line number	Diff line
	/* cell.h: AFS cell record		/* AFS cell record
	*		*
	* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.		* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
	* Written by David Howells (dhowells@redhat.com)		* Written by David Howells (dhowells@redhat.com)
	@@ -9,8 +9,8 @@
	* 2 of the License, or (at your option) any later version.		* 2 of the License, or (at your option) any later version.
	*/		*/

	#ifndef _LINUX_AFS_CELL_H		#ifndef AFS_CELL_H
	#define _LINUX_AFS_CELL_H		#define AFS_CELL_H

	#include "types.h"		#include "types.h"
	#include "cache.h"		#include "cache.h"
	@@ -19,22 +19,18 @@

	extern volatile int afs_cells_being_purged; /* T when cells are being purged by rmmod */		extern volatile int afs_cells_being_purged; /* T when cells are being purged by rmmod */

	/*****************************************************************************/
	/*		/*
	* entry in the cached cell catalogue		* entry in the cached cell catalogue
	*/		*/
	struct afs_cache_cell		struct afs_cache_cell {
	{
	char name[64]; /* cell name (padded with NULs) */		char name[64]; /* cell name (padded with NULs) */
	struct in_addr vl_servers[15]; /* cached cell VL servers */		struct in_addr vl_servers[15]; /* cached cell VL servers */
	};		};

	/*****************************************************************************/
	/*		/*
	* AFS cell record		* AFS cell record
	*/		*/
	struct afs_cell		struct afs_cell {
	{
	atomic_t usage;		atomic_t usage;
	struct list_head link; /* main cell list link */		struct list_head link; /* main cell list link */
	struct list_head proc_link; /* /proc cell list link */		struct list_head proc_link; /* /proc cell list link */
	@@ -61,18 +57,14 @@ struct afs_cell
	char name[0]; /* cell name - must go last */		char name[0]; /* cell name - must go last */
	};		};

	extern int afs_cell_init(char *rootcell);		extern int afs_cell_init(char *);
			extern int afs_cell_create(const char , char , struct afs_cell **);
	extern int afs_cell_create(const char name, char vllist, struct afs_cell **_cell);		extern int afs_cell_lookup(const char , unsigned, struct afs_cell *);

	extern int afs_cell_lookup(const char name, unsigned nmsize, struct afs_cell *_cell);

	#define afs_get_cell(C) do { atomic_inc(&(C)->usage); } while(0)		#define afs_get_cell(C) do { atomic_inc(&(C)->usage); } while(0)

	extern struct afs_cell afs_get_cell_maybe(struct afs_cell *_cell);		extern struct afs_cell afs_get_cell_maybe(struct afs_cell *);
			extern void afs_put_cell(struct afs_cell *);
	extern void afs_put_cell(struct afs_cell *cell);

	extern void afs_cell_purge(void);		extern void afs_cell_purge(void);

	#endif /* _LINUX_AFS_CELL_H */		#endif /* AFS_CELL_H */

Admin message