Subject: afs/fs/afs volume.c,1.11,1.12 vnode.h,1.8,1.9 vnode.c,1.11,1.12 vlocation.c,1.14,1.15 vlclient.h,1.5,1.6 vlclient.c,1.7,1.8 types.h,1.5,1.6 super.c,1.11,1.12 server.h,1.1.1.1,1.2 server.c,1.4,1.5 proc.c,1.4,1.5 mntpt.c,1.10,1.11 main.c,1.14,1.15 kafstimod.h,1.1.1.1,1.2 kafstimod.c,1.9,1.10 kafsasyncd.h,1.1.1.1,1.2 kafsasyncd.c,1.8,1.9 internal.h,1.19,1.20 inode.c,1.14,1.15 fsclient.h,1.1.1.1,1.2 fsclient.c,1.3,1.4 file.c,1.11,1.12 dir.c,1.12,1.13 cmservice.h,1.1.1.1,1.2 cmservice.c,1.10,1.11 cell.c,1.13,1.14 callback.c,1.5,1.6

From: [email-masked]
Date: Wed, 10 Sep 2003 14:32:40 +0100

Update of /home/cvs/afs/fs/afs
In directory phoenix.infradead.org:/tmp/cvs-serv22611/fs/afs

Modified Files:
	volume.c vnode.h vnode.c vlocation.c vlclient.h vlclient.c 
	types.h super.c server.h server.c proc.c mntpt.c main.c 
	kafstimod.h kafstimod.c kafsasyncd.h kafsasyncd.c internal.h 
	inode.c fsclient.h fsclient.c file.c dir.c cmservice.h 
	cmservice.c cell.c callback.c 
Log Message:
more coding style cleanups

Index: volume.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/volume.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -r1.11 -r1.12
--- volume.c	19 Aug 2003 13:37:08 -0000	1.11
+++ volume.c	10 Sep 2003 13:32:37 -0000	1.12
@@ -27,7 +27,8 @@
 const char *afs_voltypes[] = { "R/W", "R/O", "BAK" };
 
 #ifdef AFS_CACHING_SUPPORT
-static cachefs_match_val_t afs_volume_cache_match(void *target, const void *entry);
+static cachefs_match_val_t afs_volume_cache_match(void *target,
+						  const void *entry);
 static void afs_volume_cache_update(void *source, void *entry);
 
 struct cachefs_index_def afs_volume_cache_index_def = {
@@ -45,7 +46,8 @@
  * lookup a volume by name
  * - this can be one of the following:
  *	"%[cell:]volume[.]"		R/W volume
- *	"#[cell:]volume[.]"		R/O or R/W volume (rwparent=0), or R/W (rwparent=1) volume
+ *	"#[cell:]volume[.]"		R/O or R/W volume (rwparent=0),
+ *					 or R/W (rwparent=1) volume
  *	"%[cell:]volume.readonly"	R/O volume
  *	"#[cell:]volume.readonly"	R/O volume
  *	"%[cell:]volume.backup"		Backup volume
@@ -53,14 +55,17 @@
  *
  * The cell name is optional, and defaults to the current cell.
  *
- * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin Guide
+ * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
+ * Guide
  * - Rule 1: Explicit type suffix forces access of that type or nothing
  *           (no suffix, then use Rule 2 & 3)
- * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W if not available
- * - Rule 3: If parent volume is R/W, then only mount R/W volume unless explicitly told otherwise
+ * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
+ *           if not available
+ * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
+ *           explicitly told otherwise
  */
 int afs_volume_lookup(const char *name, struct afs_cell *cell, int rwpath,
-		      afs_volume_t **_volume)
+		      struct afs_volume **_volume)
 {
 	struct afs_vlocation *vlocation = NULL;
 	struct afs_volume *volume = NULL;
@@ -127,7 +132,8 @@
 	if (cellname || !cell) {
 		ret = afs_cell_lookup(cellname, cellnamesz, &cell);
 		if (ret<0) {
-			printk("kAFS: unable to lookup cell '%s'\n", cellname ?: "");
+			printk("kAFS: unable to lookup cell '%s'\n",
+			       cellname ?: "");
 			goto error;
 		}
 	}
@@ -146,7 +152,7 @@
 		goto error;
 
 	srvtmask = 0;
-	for (loop=0; loop<vlocation->vldb.nservers; loop++)
+	for (loop = 0; loop < vlocation->vldb.nservers; loop++)
 		srvtmask |= vlocation->vldb.srvtmask[loop];
 
 	if (force) {
@@ -177,11 +183,11 @@
 	_debug("creating new volume record");
 
 	ret = -ENOMEM;
-	volume = kmalloc(sizeof(afs_volume_t), GFP_KERNEL);
+	volume = kmalloc(sizeof(struct afs_volume), GFP_KERNEL);
 	if (!volume)
 		goto error_up;
 
-	memset(volume, 0, sizeof(afs_volume_t));
+	memset(volume, 0, sizeof(struct afs_volume));
 	atomic_set(&volume->usage, 1);
 	volume->type		= type;
 	volume->type_force	= force;
@@ -191,12 +197,13 @@
 	init_rwsem(&volume->server_sem);
 
 	/* look up all the applicable server records */
-	for (loop=0; loop<8; loop++) {
+	for (loop = 0; loop < 8; loop++) {
 		if (vlocation->vldb.srvtmask[loop] & (1 << volume->type)) {
-			ret = afs_server_lookup(volume->cell,
-						&vlocation->vldb.servers[loop],
-						&volume->servers[volume->nservers]);
-			if (ret<0)
+			ret = afs_server_lookup(
+				volume->cell,
+				&vlocation->vldb.servers[loop],
+				&volume->servers[volume->nservers]);
+			if (ret < 0)
 				goto error_discard;
 
 			volume->nservers++;
@@ -217,7 +224,8 @@
 	vlocation->vols[type] = volume;
 
  success:
-	_debug("kAFS selected %s volume %08x", afs_voltypes[volume->type], volume->vid);
+	_debug("kAFS selected %s volume %08x",
+	       afs_voltypes[volume->type], volume->vid);
 	*_volume = volume;
 	ret = 0;
 
@@ -234,7 +242,7 @@
  error_discard:
 	up_write(&cell->vl_sem);
 
-	for (loop=volume->nservers-1; loop>=0; loop--)
+	for (loop = volume->nservers - 1; loop >= 0; loop--)
 		afs_put_server(volume->servers[loop]);
 
 	kfree(volume);
@@ -245,23 +253,23 @@
 /*
  * destroy a volume record
  */
-void afs_put_volume(afs_volume_t *volume)
+void afs_put_volume(struct afs_volume *volume)
 {
-	afs_vlocation_t *vlocation;
+	struct afs_vlocation *vlocation;
 	int loop;
 
 	if (!volume)
 		return;
 
-	_enter("%p",volume);
+	_enter("%p", volume);
 
 	vlocation = volume->vlocation;
 
 	/* sanity check */
-	if (atomic_read(&volume->usage)<=0)
-		BUG();
+	BUG_ON(atomic_read(&volume->usage) <= 0);
 
-	/* to prevent a race, the decrement and the dequeue must be effectively atomic */
+	/* to prevent a race, the decrement and the dequeue must be effectively
+	 * atomic */
 	down_write(&vlocation->cell->vl_sem);
 
 	if (likely(!atomic_dec_and_test(&volume->usage))) {
@@ -276,11 +284,11 @@
 
 	/* finish cleaning up the volume */
 #ifdef AFS_CACHING_SUPPORT
-	cachefs_relinquish_cookie(volume->cache,0);
+	cachefs_relinquish_cookie(volume->cache, 0);
 #endif
 	afs_put_vlocation(vlocation);
 
-	for (loop=volume->nservers-1; loop>=0; loop--)
+	for (loop = volume->nservers - 1; loop >= 0; loop--)
 		afs_put_server(volume->servers[loop]);
 
 	kfree(volume);
@@ -293,26 +301,28 @@
  * pick a server to use to try accessing this volume
  * - returns with an elevated usage count on the server chosen
  */
-int afs_volume_pick_fileserver(afs_volume_t *volume, afs_server_t **_server)
+int afs_volume_pick_fileserver(struct afs_volume *volume,
+			       struct afs_server **_server)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	int ret, state, loop;
 
-	_enter("%s",volume->vlocation->vldb.name);
+	_enter("%s", volume->vlocation->vldb.name);
 
 	down_read(&volume->server_sem);
 
 	/* handle the no-server case */
-	if (volume->nservers==0) {
+	if (volume->nservers == 0) {
 		ret = volume->rjservers ? -ENOMEDIUM : -ESTALE;
 		up_read(&volume->server_sem);
-		_leave(" = %d [no servers]",ret);
+		_leave(" = %d [no servers]", ret);
 		return ret;
 	}
 
-	/* basically, just search the list for the first live server and use that */
+	/* basically, just search the list for the first live server and use
+	 * that */
 	ret = 0;
-	for (loop=0; loop<volume->nservers; loop++) {
+	for (loop = 0; loop < volume->nservers; loop++) {
 		server = volume->servers[loop];
 		state = server->fs_state;
 
@@ -322,30 +332,34 @@
 			afs_get_server(server);
 			up_read(&volume->server_sem);
 			*_server = server;
-			_leave(" = 0 (picked %08x)",ntohl(server->addr.s_addr));
+			_leave(" = 0 (picked %08x)",
+			       ntohl(server->addr.s_addr));
 			return 0;
 
 		case -ENETUNREACH:
-			if (ret==0)
+			if (ret == 0)
 				ret = state;
 			break;
 
 		case -EHOSTUNREACH:
-			if (ret==0 || ret==-ENETUNREACH)
+			if (ret == 0 ||
+			    ret == -ENETUNREACH)
 				ret = state;
 			break;
 
 		case -ECONNREFUSED:
-			if (ret==0 || ret==-ENETUNREACH || ret==-EHOSTUNREACH)
+			if (ret == 0 ||
+			    ret == -ENETUNREACH ||
+			    ret == -EHOSTUNREACH)
 				ret = state;
 			break;
 
 		default:
 		case -EREMOTEIO:
-			if (ret==0 ||
-			    ret==-ENETUNREACH ||
-			    ret==-EHOSTUNREACH ||
-			    ret==-ECONNREFUSED)
+			if (ret == 0 ||
+			    ret == -ENETUNREACH ||
+			    ret == -EHOSTUNREACH ||
+			    ret == -ECONNREFUSED)
 				ret = state;
 			break;
 		}
@@ -355,7 +369,7 @@
 	 * - TODO: handle the no active servers case better
 	 */
 	up_read(&volume->server_sem);
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_volume_pick_fileserver() */
 
@@ -366,11 +380,15 @@
  * - records result of using a particular server to access a volume
  * - return 0 to try again, 1 if okay or to issue error
  */
-int afs_volume_release_fileserver(afs_volume_t *volume, afs_server_t *server, int result)
+int afs_volume_release_fileserver(struct afs_volume *volume,
+				  struct afs_server *server,
+				  int result)
 {
 	unsigned loop;
 
-	_enter("%s,%08x,%d",volume->vlocation->vldb.name,ntohl(server->addr.s_addr),result);
+	_enter("%s,%08x,%d",
+	       volume->vlocation->vldb.name, ntohl(server->addr.s_addr),
+	       result);
 
 	switch (result) {
 		/* success */
@@ -383,9 +401,10 @@
 		server->fs_act_jif = jiffies;
 		down_write(&volume->server_sem);
 
-		/* first, find where the server is in the active list (if it is) */
-		for (loop=0; loop<volume->nservers; loop++)
-			if (volume->servers[loop]==server)
+		/* first, find where the server is in the active list (if it
+		 * is) */
+		for (loop = 0; loop < volume->nservers; loop++)
+			if (volume->servers[loop] == server)
 				goto present;
 
 		/* no longer there - may have been discarded by another op */
@@ -394,20 +413,22 @@
 	present:
 		volume->nservers--;
 		memmove(&volume->servers[loop],
-			&volume->servers[loop+1],
-			sizeof(volume->servers[loop]) * (volume->nservers - loop)
-			);
+			&volume->servers[loop + 1],
+			sizeof(volume->servers[loop]) *
+			(volume->nservers - loop));
 		volume->servers[volume->nservers] = NULL;
 		afs_put_server(server);
 		volume->rjservers++;
 
-		if (volume->nservers>0)
+		if (volume->nservers > 0)
 			/* another server might acknowledge its existence */
 			goto try_next_server_upw;
 
-		/* handle the case where all the fileservers have rejected the volume
+		/* handle the case where all the fileservers have rejected the
+		 * volume
 		 * - TODO: try asking the fileservers for volume information
-		 * - TODO: contact the VL server again to see if the volume is no longer registered
+		 * - TODO: contact the VL server again to see if the volume is
+		 *         no longer registered
 		 */
 		up_write(&volume->server_sem);
 		afs_put_server(server);
@@ -427,7 +448,7 @@
 		if (!server->fs_state) {
 			server->fs_dead_jif = jiffies + HZ * 10;
 			server->fs_state = result;
-			printk("kAFS: SERVER DEAD state=%d\n",result);
+			printk("kAFS: SERVER DEAD state=%d\n", result);
 		}
 		spin_unlock(&server->fs_lock);
 		goto try_next_server;
@@ -460,7 +481,8 @@
  * match a volume hash record stored in the cache
  */
 #ifdef AFS_CACHING_SUPPORT
-static cachefs_match_val_t afs_volume_cache_match(void *target, const void *entry)
+static cachefs_match_val_t afs_volume_cache_match(void *target,
+						  const void *entry)
 {
 	const struct afs_cache_vhash *vhash = entry;
 	struct afs_volume *volume = target;

Index: vnode.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/vnode.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -r1.8 -r1.9
--- vnode.h	10 Sep 2003 08:23:15 -0000	1.8
+++ vnode.h	10 Sep 2003 13:32:37 -0000	1.9
@@ -70,21 +70,22 @@
 	afs_callback_type_t	cb_type;	/* type of callback */
 };
 
-static inline afs_vnode_t *AFS_FS_I(struct inode *inode)
+static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
 {
-	return container_of(inode,afs_vnode_t,vfs_inode);
+	return container_of(inode,struct afs_vnode,vfs_inode);
 }
 
-static inline struct inode *AFS_VNODE_TO_I(afs_vnode_t *vnode)
+static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
 {
 	return &vnode->vfs_inode;
 }
 
-extern int afs_vnode_fetch_status(afs_vnode_t *vnode);
+extern int afs_vnode_fetch_status(struct afs_vnode *vnode);
 
-extern int afs_vnode_fetch_data(afs_vnode_t *vnode, struct afs_rxfs_fetch_descriptor *desc);
+extern int afs_vnode_fetch_data(struct afs_vnode *vnode,
+				struct afs_rxfs_fetch_descriptor *desc);
 
-extern int afs_vnode_give_up_callback(afs_vnode_t *vnode);
+extern int afs_vnode_give_up_callback(struct afs_vnode *vnode);
 
 extern struct afs_timer_ops afs_vnode_cb_timed_out_ops;

Index: vnode.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/vnode.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -r1.11 -r1.12
--- vnode.c	10 Sep 2003 08:23:15 -0000	1.11
+++ vnode.c	10 Sep 2003 13:32:37 -0000	1.12
@@ -30,7 +30,8 @@
 };
 
 #ifdef AFS_CACHING_SUPPORT
-static cachefs_match_val_t afs_vnode_cache_match(void *target, const void *entry);
+static cachefs_match_val_t afs_vnode_cache_match(void *target,
+						 const void *entry);
 static void afs_vnode_cache_update(void *source, void *entry);
 
 struct cachefs_index_def afs_vnode_cache_index_def = {
@@ -49,17 +50,17 @@
  */
 static void afs_vnode_cb_timed_out(struct afs_timer *timer)
 {
-	afs_server_t *oldserver;
-	afs_vnode_t *vnode;
+	struct afs_server *oldserver;
+	struct afs_vnode *vnode;
 
-	vnode = list_entry(timer,afs_vnode_t,cb_timeout);
+	vnode = list_entry(timer, struct afs_vnode, cb_timeout);
 
-	_enter("%p",vnode);
+	_enter("%p", vnode);
 
 	/* set the changed flag in the vnode and release the server */
 	spin_lock(&vnode->lock);
 
-	oldserver = xchg(&vnode->cb_server,NULL);
+	oldserver = xchg(&vnode->cb_server, NULL);
 	if (oldserver) {
 		vnode->flags |= AFS_VNODE_CHANGED;
 
@@ -85,28 +86,33 @@
  * - starts callback expiry timer
  * - adds to server's callback list
  */
-void afs_vnode_finalise_status_update(afs_vnode_t *vnode, afs_server_t *server, int ret)
+void afs_vnode_finalise_status_update(struct afs_vnode *vnode,
+				      struct afs_server *server,
+				      int ret)
 {
-	afs_server_t *oldserver = NULL;
+	struct afs_server *oldserver = NULL;
 
-	_enter("%p,%p,%d",vnode,server,ret);
+	_enter("%p,%p,%d", vnode, server, ret);
 
 	spin_lock(&vnode->lock);
 
 	vnode->flags &= ~AFS_VNODE_CHANGED;
 
-	if (ret==0) {
+	if (ret == 0) {
 		/* adjust the callback timeout appropriately */
-		afs_kafstimod_add_timer(&vnode->cb_timeout,vnode->cb_expiry*HZ);
+		afs_kafstimod_add_timer(&vnode->cb_timeout,
+					vnode->cb_expiry * HZ);
 
 		spin_lock(&afs_cb_hash_lock);
 		list_del(&vnode->cb_hash_link);
-		list_add_tail(&vnode->cb_hash_link,&afs_cb_hash(server,&vnode->fid));
+		list_add_tail(&vnode->cb_hash_link,
+			      &afs_cb_hash(server, &vnode->fid));
 		spin_unlock(&afs_cb_hash_lock);
 
-		/* swap ref to old callback server with that for new callback server */
-		oldserver = xchg(&vnode->cb_server,server);
-		if (oldserver!=server) {
+		/* swap ref to old callback server with that for new callback
+		 * server */
+		oldserver = xchg(&vnode->cb_server, server);
+		if (oldserver != server) {
 			if (oldserver) {
 				spin_lock(&oldserver->cb_lock);
 				list_del_init(&vnode->cb_link);
@@ -115,7 +121,7 @@
 
 			afs_get_server(server);
 			spin_lock(&server->cb_lock);
-			list_add_tail(&vnode->cb_link,&server->cb_promises);
+			list_add_tail(&vnode->cb_link, &server->cb_promises);
 			spin_unlock(&server->cb_lock);
 		}
 		else {
@@ -123,9 +129,9 @@
 			oldserver = NULL;
 		}
 	}
-	else if (ret==-ENOENT) {
+	else if (ret == -ENOENT) {
 		/* the file was deleted - clear the callback timeout */
-		oldserver = xchg(&vnode->cb_server,NULL);
+		oldserver = xchg(&vnode->cb_server, NULL);
 		afs_kafstimod_del_timer(&vnode->cb_timeout);
 
 		_debug("got NOENT from server - marking file deleted");
@@ -152,15 +158,16 @@
  *   - there are any outstanding ops that will fetch the status
  * - TODO implement local caching
  */
-int afs_vnode_fetch_status(afs_vnode_t *vnode)
+int afs_vnode_fetch_status(struct afs_vnode *vnode)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	int ret;
 
-	DECLARE_WAITQUEUE(myself,current);
+	DECLARE_WAITQUEUE(myself, current);
 
-	_enter("%s,{%u,%u,%u}",vnode->volume->vlocation->vldb.name,
-	       vnode->fid.vid,vnode->fid.vnode,vnode->fid.unique);
+	_enter("%s,{%u,%u,%u}",
+	       vnode->volume->vlocation->vldb.name,
+	       vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
 
 	if (!(vnode->flags & AFS_VNODE_CHANGED) && vnode->cb_server) {
 		_leave(" [unchanged]");
@@ -180,19 +187,23 @@
 		return 0;
 	}
 
-	if (vnode->update_cnt>0) {
+	if (vnode->update_cnt > 0) {
 		/* someone else started a fetch */
 		set_current_state(TASK_UNINTERRUPTIBLE);
-		add_wait_queue(&vnode->update_waitq,&myself);
+		add_wait_queue(&vnode->update_waitq, &myself);
 
 		/* wait for the status to be updated */
 		for (;;) {
-			if (!(vnode->flags & AFS_VNODE_CHANGED))	break;
-			if (vnode->flags & AFS_VNODE_DELETED)		break;
-
-			/* it got updated and invalidated all before we saw it */
-			if (vnode->update_cnt==0) {
-				remove_wait_queue(&vnode->update_waitq,&myself);
+			if (!(vnode->flags & AFS_VNODE_CHANGED))
+				break;
+			if (vnode->flags & AFS_VNODE_DELETED)
+				break;
+
+			/* it got updated and invalidated all before we saw
+			 * it */
+			if (vnode->update_cnt == 0) {
+				remove_wait_queue(&vnode->update_waitq,
+						  &myself);
 				set_current_state(TASK_RUNNING);
 				goto get_anyway;
 			}
@@ -205,7 +216,7 @@
 			spin_lock(&vnode->lock);
 		}
 
-		remove_wait_queue(&vnode->update_waitq,&myself);
+		remove_wait_queue(&vnode->update_waitq, &myself);
 		spin_unlock(&vnode->lock);
 		set_current_state(TASK_RUNNING);
 
@@ -218,23 +229,24 @@
 
 	spin_unlock(&vnode->lock);
 
-	/* merge AFS status fetches and clear outstanding callback on this vnode */
+	/* merge AFS status fetches and clear outstanding callback on this
+	 * vnode */
 	do {
 		/* pick a server to query */
-		ret = afs_volume_pick_fileserver(vnode->volume,&server);
+		ret = afs_volume_pick_fileserver(vnode->volume, &server);
 		if (ret<0)
 			return ret;
 
-		_debug("USING SERVER: %08x\n",ntohl(server->addr.s_addr));
+		_debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
 
-		ret = afs_rxfs_fetch_file_status(server,vnode,NULL);
+		ret = afs_rxfs_fetch_file_status(server, vnode, NULL);
 
-	} while (!afs_volume_release_fileserver(vnode->volume,server,ret));
+	} while (!afs_volume_release_fileserver(vnode->volume, server, ret));
 
 	/* adjust the flags */
-	afs_vnode_finalise_status_update(vnode,server,ret);
+	afs_vnode_finalise_status_update(vnode, server, ret);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_vnode_fetch_status() */
 
@@ -243,9 +255,10 @@
  * fetch file data from the volume
  * - TODO implement caching and server failover
  */
-int afs_vnode_fetch_data(afs_vnode_t *vnode, struct afs_rxfs_fetch_descriptor *desc)
+int afs_vnode_fetch_data(struct afs_vnode *vnode,
+			 struct afs_rxfs_fetch_descriptor *desc)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	int ret;
 
 	_enter("%s,{%u,%u,%u}",
@@ -259,23 +272,24 @@
 	vnode->update_cnt++;
 	spin_unlock(&vnode->lock);
 
-	/* merge in AFS status fetches and clear outstanding callback on this vnode */
+	/* merge in AFS status fetches and clear outstanding callback on this
+	 * vnode */
 	do {
 		/* pick a server to query */
-		ret = afs_volume_pick_fileserver(vnode->volume,&server);
-		if (ret<0)
+		ret = afs_volume_pick_fileserver(vnode->volume, &server);
+		if (ret < 0)
 			return ret;
 
-		_debug("USING SERVER: %08x\n",ntohl(server->addr.s_addr));
+		_debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
 
-		ret = afs_rxfs_fetch_file_data(server,vnode,desc,NULL);
+		ret = afs_rxfs_fetch_file_data(server, vnode, desc, NULL);
 
-	} while (!afs_volume_release_fileserver(vnode->volume,server,ret));
+	} while (!afs_volume_release_fileserver(vnode->volume, server, ret));
 
 	/* adjust the flags */
-	afs_vnode_finalise_status_update(vnode,server,ret);
+	afs_vnode_finalise_status_update(vnode, server, ret);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_vnode_fetch_data() */
@@ -285,9 +299,9 @@
  * break any outstanding callback on a vnode
  * - only relevent to server that issued it
  */
-int afs_vnode_give_up_callback(afs_vnode_t *vnode)
+int afs_vnode_give_up_callback(struct afs_vnode *vnode)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	int ret;
 
 	_enter("%s,{%u,%u,%u}",
@@ -305,7 +319,7 @@
 
 	afs_kafstimod_del_timer(&vnode->cb_timeout);
 
-	server = xchg(&vnode->cb_server,NULL);
+	server = xchg(&vnode->cb_server, NULL);
 	if (server) {
 		vnode->flags |= AFS_VNODE_CHANGED;
 
@@ -318,11 +332,11 @@
 
 	ret = 0;
 	if (server) {
-		ret = afs_rxfs_give_up_callback(server,vnode);
+		ret = afs_rxfs_give_up_callback(server, vnode);
 		afs_put_server(server);
 	}
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_vnode_give_up_callback() */
 
@@ -331,7 +345,8 @@
  * match a vnode record stored in the cache
  */
 #ifdef AFS_CACHING_SUPPORT
-static cachefs_match_val_t afs_vnode_cache_match(void *target, const void *entry)
+static cachefs_match_val_t afs_vnode_cache_match(void *target,
+						 const void *entry)
 {
 	const struct afs_cache_vnode *cvnode = entry;
 	struct afs_vnode *vnode = target;

Index: vlocation.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/vlocation.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -r1.14 -r1.15
--- vlocation.c	10 Sep 2003 08:23:15 -0000	1.14
+++ vlocation.c	10 Sep 2003 13:32:37 -0000	1.15
@@ -26,15 +26,17 @@
 
 #define AFS_VLDB_TIMEOUT HZ*1000
 
-static void afs_vlocation_update_timer(afs_timer_t *timer);
-static void afs_vlocation_update_attend(afs_async_op_t *op);
-static void afs_vlocation_update_discard(afs_async_op_t *op);
+static void afs_vlocation_update_timer(struct afs_timer *timer);
+static void afs_vlocation_update_attend(struct afs_async_op *op);
+static void afs_vlocation_update_discard(struct afs_async_op *op);
 
-static void __afs_vlocation_timeout(afs_timer_t *timer)
+static void __afs_vlocation_timeout(struct afs_timer *timer)
 {
-	afs_vlocation_t *vlocation = list_entry(timer,afs_vlocation_t,timeout);
+	struct afs_vlocation *vlocation =
+		list_entry(timer, struct afs_vlocation, timeout);
 
-	_debug("VL TIMEOUT [%s{u=%d}]",vlocation->vldb.name,atomic_read(&vlocation->usage));
+	_debug("VL TIMEOUT [%s{u=%d}]",
+	       vlocation->vldb.name, atomic_read(&vlocation->usage));
 
 	afs_vlocation_do_timeout(vlocation);
 }
@@ -53,11 +55,12 @@
 };
 
 static LIST_HEAD(afs_vlocation_update_pendq);	/* queue of VLs awaiting update */
-static afs_vlocation_t *afs_vlocation_update;	/* VL currently being updated */
+static struct afs_vlocation *afs_vlocation_update;	/* VL currently being updated */
 static spinlock_t afs_vlocation_update_lock = SPIN_LOCK_UNLOCKED; /* lock guarding update queue */
 
 #ifdef AFS_CACHING_SUPPORT
-static cachefs_match_val_t afs_vlocation_cache_match(void *target, const void *entry);
+static cachefs_match_val_t afs_vlocation_cache_match(void *target,
+						     const void *entry);
 static void afs_vlocation_cache_update(void *source, void *entry);
 
 struct cachefs_index_def afs_vlocation_cache_index_def = {
@@ -71,29 +74,31 @@
 
 /*****************************************************************************/
 /*
- * iterate through the VL servers in a cell until one of them admits knowing about the volume in
- * question
+ * iterate through the VL servers in a cell until one of them admits knowing
+ * about the volume in question
  * - caller must have cell->vl_sem write-locked
  */
-static int afs_vlocation_access_vl_by_name(afs_vlocation_t *vlocation,
+static int afs_vlocation_access_vl_by_name(struct afs_vlocation *vlocation,
 					   const char *name,
 					   unsigned namesz,
 					   struct afs_cache_vlocation *vldb)
 {
-	afs_server_t *server = NULL;
-	afs_cell_t *cell = vlocation->cell;
+	struct afs_server *server = NULL;
+	struct afs_cell *cell = vlocation->cell;
 	int count, ret;
 
 	_enter("%s,%*.*s,%u", cell->name, namesz, namesz, name, namesz);
 
 	ret = -ENOMEDIUM;
-	for (count=cell->vl_naddrs; count>0; count--) {
+	for (count = cell->vl_naddrs; count > 0; count--) {
 		_debug("CellServ[%hu]: %08x",
 		       cell->vl_curr_svix,
 		       cell->vl_addrs[cell->vl_curr_svix].s_addr);
 
 		/* try and create a server */
-		ret = afs_server_lookup(cell, &cell->vl_addrs[cell->vl_curr_svix], &server);
+		ret = afs_server_lookup(cell,
+					&cell->vl_addrs[cell->vl_curr_svix],
+					&server);
 		switch (ret) {
 		case 0:
 			break;
@@ -141,36 +146,38 @@
 	}
 
  out:
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_vlocation_access_vl_by_name() */
 
 /*****************************************************************************/
 /*
- * iterate through the VL servers in a cell until one of them admits knowing about the volume in
- * question
+ * iterate through the VL servers in a cell until one of them admits knowing
+ * about the volume in question
  * - caller must have cell->vl_sem write-locked
  */
-static int afs_vlocation_access_vl_by_id(afs_vlocation_t *vlocation,
+static int afs_vlocation_access_vl_by_id(struct afs_vlocation *vlocation,
 					 afs_volid_t volid,
 					 afs_voltype_t voltype,
 					 struct afs_cache_vlocation *vldb)
 {
-	afs_server_t *server = NULL;
-	afs_cell_t *cell = vlocation->cell;
+	struct afs_server *server = NULL;
+	struct afs_cell *cell = vlocation->cell;
 	int count, ret;
 
 	_enter("%s,%x,%d,", cell->name, volid, voltype);
 
 	ret = -ENOMEDIUM;
-	for (count=cell->vl_naddrs; count>0; count--) {
+	for (count = cell->vl_naddrs; count > 0; count--) {
 		_debug("CellServ[%hu]: %08x",
 		       cell->vl_curr_svix,
 		       cell->vl_addrs[cell->vl_curr_svix].s_addr);
 
 		/* try and create a server */
-		ret = afs_server_lookup(cell, &cell->vl_addrs[cell->vl_curr_svix], &server);
+		ret = afs_server_lookup(cell,
+					&cell->vl_addrs[cell->vl_curr_svix],
+					&server);
 		switch (ret) {
 		case 0:
 			break;
@@ -218,7 +225,7 @@
 	}
 
  out:
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_vlocation_access_vl_by_id() */
@@ -227,17 +234,19 @@
 /*
  * lookup volume location
  * - caller must have cell->vol_sem write-locked
- * - iterate through the VL servers in a cell until one of them admits knowing about the volume in
- *   question
+ * - iterate through the VL servers in a cell until one of them admits knowing
+ *   about the volume in question
  * - lookup in the local cache if not able to find on the VL server
  * - insert/update in the local cache if did get a VL response
  */
-int afs_vlocation_lookup(afs_cell_t *cell, const char *name, unsigned namesz,
-			 afs_vlocation_t **_vlocation)
+int afs_vlocation_lookup(struct afs_cell *cell,
+			 const char *name,
+			 unsigned namesz,
+			 struct afs_vlocation **_vlocation)
 {
 	struct afs_cache_vlocation vldb;
 	struct list_head *_p;
-	afs_vlocation_t *vlocation;
+	struct afs_vlocation *vlocation;
 	afs_voltype_t voltype;
 	afs_volid_t vid;
 	int active = 0, ret;
@@ -251,7 +260,7 @@
 
 	/* search the cell's active list first */
 	list_for_each(_p, &cell->vl_list) {
-		vlocation = list_entry(_p, afs_vlocation_t, link);
+		vlocation = list_entry(_p, struct afs_vlocation, link);
 		if (namesz < sizeof(vlocation->vldb.name) &&
 		    vlocation->vldb.name[namesz] != '\0')
 			continue;
@@ -263,7 +272,7 @@
 	/* search the cell's graveyard list second */
 	spin_lock(&cell->vl_gylock);
 	list_for_each(_p, &cell->vl_graveyard) {
-		vlocation = list_entry(_p, afs_vlocation_t, link);
+		vlocation = list_entry(_p, struct afs_vlocation, link);
 		if (namesz < sizeof(vlocation->vldb.name) &&
 		    vlocation->vldb.name[namesz] != '\0')
 			continue;
@@ -274,11 +283,11 @@
 	spin_unlock(&cell->vl_gylock);
 
 	/* not in the cell's in-memory lists - create a new record */
-	vlocation = kmalloc(sizeof(afs_vlocation_t), GFP_KERNEL);
+	vlocation = kmalloc(sizeof(struct afs_vlocation), GFP_KERNEL);
 	if (!vlocation)
 		return -ENOMEM;
 
-	memset(vlocation, 0, sizeof(afs_vlocation_t));
+	memset(vlocation, 0, sizeof(struct afs_vlocation));
 	atomic_set(&vlocation->usage, 1);
 	INIT_LIST_HEAD(&vlocation->link);
 	rwlock_init(&vlocation->lock);
@@ -294,7 +303,8 @@
 	list_add_tail(&vlocation->link, &cell->vl_list);
 
 #ifdef AFS_CACHING_SUPPORT
-	/* we want to store it in the cache, plus it might already be encached */
+	/* we want to store it in the cache, plus it might already be
+	 * encached */
 	cachefs_acquire_cookie(cell->cache,
 			       &afs_volume_cache_index_def,
 			       vlocation,
@@ -306,7 +316,7 @@
 
 	/* try to look up an unknown volume in the cell VL databases by name */
 	ret = afs_vlocation_access_vl_by_name(vlocation, name, namesz, &vldb);
-	if (ret<0) {
+	if (ret < 0) {
 		printk("kAFS: failed to locate '%*.*s' in cell '%s'\n",
 		       namesz, namesz, name, cell->name);
 		goto error;
@@ -342,13 +352,18 @@
 	_debug("Locally Cached: %s %02x { %08x(%x) %08x(%x) %08x(%x) }",
 	       vlocation->vldb.name,
 	       vlocation->vldb.vidmask,
-	       ntohl(vlocation->vldb.servers[0].s_addr), vlocation->vldb.srvtmask[0],
-	       ntohl(vlocation->vldb.servers[1].s_addr), vlocation->vldb.srvtmask[1],
-	       ntohl(vlocation->vldb.servers[2].s_addr), vlocation->vldb.srvtmask[2]
+	       ntohl(vlocation->vldb.servers[0].s_addr),
+	       vlocation->vldb.srvtmask[0],
+	       ntohl(vlocation->vldb.servers[1].s_addr),
+	       vlocation->vldb.srvtmask[1],
+	       ntohl(vlocation->vldb.servers[2].s_addr),
+	       vlocation->vldb.srvtmask[2]
 	       );
 
 	_debug("Vids: %08x %08x %08x",
-	       vlocation->vldb.vid[0], vlocation->vldb.vid[1], vlocation->vldb.vid[2]);
+	       vlocation->vldb.vid[0],
+	       vlocation->vldb.vid[1],
+	       vlocation->vldb.vid[2]);
 
 	if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) {
 		vid = vlocation->vldb.vid[0];
@@ -400,22 +415,20 @@
 
 	_debug("Vids: %08x %08x %08x", vldb.vid[0], vldb.vid[1], vldb.vid[2]);
 
-	if ((namesz < sizeof(vlocation->vldb.name) && vlocation->vldb.name[namesz] != '\0') ||
+	if ((namesz < sizeof(vlocation->vldb.name) &&
+	     vlocation->vldb.name[namesz] != '\0') ||
 	    memcmp(vldb.name, name, namesz) != 0)
 		printk("kAFS: name of volume '%*.*s' changed to '%s' on server\n",
 		       namesz, namesz, name, vldb.name);
 
 	memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb));
 
+	afs_kafstimod_add_timer(&vlocation->upd_timer, 10 * HZ);
+
 #if 0
-	/* add volume entry to local cache */
-	ret = afsc_update_vlocation(vlocation);
-	if (ret<0)
-		goto error;
+	/* TODO: update volume entry in local cache */
 #endif
 
-	afs_kafstimod_add_timer(&vlocation->upd_timer, 10*HZ);
-
 	*_vlocation = vlocation;
 	_leave(" = 0 (%p)",vlocation);
 	return 0;
@@ -435,7 +448,7 @@
 		}
 	}
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_vlocation_lookup() */
 
@@ -451,13 +464,12 @@
 	if (!vlocation)
 		return;
 
-	_enter("%s",vlocation->vldb.name);
+	_enter("%s", vlocation->vldb.name);
 
 	cell = vlocation->cell;
 
 	/* sanity check */
-	if (atomic_read(&vlocation->usage)<=0)
-		BUG();
+	BUG_ON(atomic_read(&vlocation->usage) <= 0);
 
 	spin_lock(&cell->vl_gylock);
 	if (likely(!atomic_dec_and_test(&vlocation->usage))) {
@@ -470,12 +482,13 @@
 	list_del(&vlocation->link);
 	list_add_tail(&vlocation->link,&cell->vl_graveyard);
 
-	/* remove from pending timeout queue (refcounted if actually being updated) */
+	/* remove from pending timeout queue (refcounted if actually being
+	 * updated) */
 	list_del_init(&vlocation->upd_op.link);
 
 	/* time out in 10 secs */
 	afs_kafstimod_del_timer(&vlocation->upd_timer);
-	afs_kafstimod_add_timer(&vlocation->timeout,10*HZ);
+	afs_kafstimod_add_timer(&vlocation->timeout, 10 * HZ);
 
 	spin_unlock(&cell->vl_gylock);
 
@@ -486,7 +499,7 @@
 /*
  * finish using a volume location record
  */
-void afs_put_vlocation(afs_vlocation_t *vlocation)
+void afs_put_vlocation(struct afs_vlocation *vlocation)
 {
 	if (vlocation) {
 		struct afs_cell *cell = vlocation->cell;
@@ -502,19 +515,19 @@
  * timeout vlocation record
  * - removes from the cell's graveyard if the usage count is zero
  */
-void afs_vlocation_do_timeout(afs_vlocation_t *vlocation)
+void afs_vlocation_do_timeout(struct afs_vlocation *vlocation)
 {
-	afs_cell_t *cell;
+	struct afs_cell *cell;
 
-	_enter("%s",vlocation->vldb.name);
+	_enter("%s", vlocation->vldb.name);
 
 	cell = vlocation->cell;
 
-	if (atomic_read(&vlocation->usage)<0) BUG();
+	BUG_ON(atomic_read(&vlocation->usage) < 0);
 
 	/* remove from graveyard if still dead */
 	spin_lock(&cell->vl_gylock);
-	if (atomic_read(&vlocation->usage)==0)
+	if (atomic_read(&vlocation->usage) == 0)
 		list_del_init(&vlocation->link);
 	else
 		vlocation = NULL;
@@ -527,7 +540,7 @@
 
 	/* we can now destroy it properly */
 #ifdef AFS_CACHING_SUPPORT
-	cachefs_relinquish_cookie(vlocation->cache,0);
+	cachefs_relinquish_cookie(vlocation->cache, 0);
 #endif
 	afs_put_cell(cell);
 
@@ -540,14 +553,16 @@
 /*
  * send an update operation to the currently selected server
  */
-static int afs_vlocation_update_begin(afs_vlocation_t *vlocation)
+static int afs_vlocation_update_begin(struct afs_vlocation *vlocation)
 {
 	afs_voltype_t voltype;
 	afs_volid_t vid;
 	int ret;
 
 	_enter("%s{ufs=%u ucs=%u}",
-	       vlocation->vldb.name,vlocation->upd_first_svix,vlocation->upd_curr_svix);
+	       vlocation->vldb.name,
+	       vlocation->upd_first_svix,
+	       vlocation->upd_curr_svix);
 
 	/* try to look up a cached volume in the cell VL databases by ID */
 	if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) {
@@ -569,27 +584,29 @@
 	}
 
 	/* contact the chosen server */
-	ret = afs_server_lookup(vlocation->cell,
-				&vlocation->cell->vl_addrs[vlocation->upd_curr_svix],
-				&vlocation->upd_op.server);
+	ret = afs_server_lookup(
+		vlocation->cell,
+		&vlocation->cell->vl_addrs[vlocation->upd_curr_svix],
+		&vlocation->upd_op.server);
+
 	switch (ret) {
 	case 0:
 		break;
 	case -ENOMEM:
 	case -ENONET:
 	default:
-		_leave(" = %d",ret);
+		_leave(" = %d", ret);
 		return ret;
 	}
 
 	/* initiate the update operation */
-	ret = afs_rxvl_get_entry_by_id_async(&vlocation->upd_op,vid,voltype);
-	if (ret<0) {
-		_leave(" = %d",ret);
+	ret = afs_rxvl_get_entry_by_id_async(&vlocation->upd_op, vid, voltype);
+	if (ret < 0) {
+		_leave(" = %d", ret);
 		return ret;
 	}
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_vlocation_update_begin() */
 
@@ -598,14 +615,15 @@
  * abandon updating a VL record
  * - does not restart the update timer
  */
-static void afs_vlocation_update_abandon(afs_vlocation_t *vlocation,
+static void afs_vlocation_update_abandon(struct afs_vlocation *vlocation,
 					 afs_vlocation_upd_t state,
 					 int ret)
 {
-	_enter("%s,%u",vlocation->vldb.name,state);
+	_enter("%s,%u", vlocation->vldb.name, state);
 
-	if (ret<0)
-		printk("kAFS: Abandoning VL update '%s': %d\n",vlocation->vldb.name,ret);
+	if (ret < 0)
+		printk("kAFS: Abandoning VL update '%s': %d\n",
+		       vlocation->vldb.name, ret);
 
 	/* discard the server record */
 	afs_put_server(vlocation->upd_op.server);
@@ -627,12 +645,13 @@
  * handle periodic update timeouts and busy retry timeouts
  * - called from kafstimod
  */
-static void afs_vlocation_update_timer(afs_timer_t *timer)
+static void afs_vlocation_update_timer(struct afs_timer *timer)
 {
-	afs_vlocation_t *vlocation = list_entry(timer,afs_vlocation_t,upd_timer);
+	struct afs_vlocation *vlocation =
+		list_entry(timer, struct afs_vlocation, upd_timer);
 	int ret;
 
-	_enter("%s",vlocation->vldb.name);
+	_enter("%s", vlocation->vldb.name);
 
 	/* only update if not in the graveyard (defend against putting too) */
 	spin_lock(&vlocation->cell->vl_gylock);
@@ -642,11 +661,12 @@
 
 	spin_lock(&afs_vlocation_update_lock);
 
-	/* if we were woken up due to EBUSY sleep then restart immediately if possible or else jump
-	 * to front of pending queue */
-	if (vlocation->upd_state==AFS_VLUPD_BUSYSLEEP) {
+	/* if we were woken up due to EBUSY sleep then restart immediately if
+	 * possible or else jump to front of pending queue */
+	if (vlocation->upd_state == AFS_VLUPD_BUSYSLEEP) {
 		if (afs_vlocation_update) {
-			list_add(&vlocation->upd_op.link,&afs_vlocation_update_pendq);
+			list_add(&vlocation->upd_op.link,
+				 &afs_vlocation_update_pendq);
 		}
 		else {
 			afs_get_vlocation(vlocation);
@@ -659,7 +679,8 @@
 	/* put on pending queue if there's already another update in progress */
 	if (afs_vlocation_update) {
 		vlocation->upd_state = AFS_VLUPD_PENDING;
-		list_add_tail(&vlocation->upd_op.link,&afs_vlocation_update_pendq);
+		list_add_tail(&vlocation->upd_op.link,
+			      &afs_vlocation_update_pendq);
 		goto out_unlock2;
 	}
 
@@ -672,16 +693,17 @@
 	spin_unlock(&vlocation->cell->vl_gylock);
 
 	/* okay... we can start the update */
-	_debug("BEGIN VL UPDATE [%s]",vlocation->vldb.name);
+	_debug("BEGIN VL UPDATE [%s]", vlocation->vldb.name);
 	vlocation->upd_first_svix = vlocation->cell->vl_curr_svix;
 	vlocation->upd_curr_svix = vlocation->upd_first_svix;
 	vlocation->upd_rej_cnt = 0;
 	vlocation->upd_busy_cnt = 0;
 
 	ret = afs_vlocation_update_begin(vlocation);
-	if (ret<0) {
-		afs_vlocation_update_abandon(vlocation,AFS_VLUPD_SLEEP,ret);
-		afs_kafstimod_add_timer(&vlocation->upd_timer,AFS_VLDB_TIMEOUT);
+	if (ret < 0) {
+		afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret);
+		afs_kafstimod_add_timer(&vlocation->upd_timer,
+					AFS_VLDB_TIMEOUT);
 		afs_put_vlocation(vlocation);
 	}
 
@@ -702,56 +724,60 @@
  * attend to an update operation upon which an event happened
  * - called in kafsasyncd context
  */
-static void afs_vlocation_update_attend(afs_async_op_t *op)
+static void afs_vlocation_update_attend(struct afs_async_op *op)
 {
 	struct afs_cache_vlocation vldb;
-	afs_vlocation_t *vlocation = list_entry(op,afs_vlocation_t,upd_op);
+	struct afs_vlocation *vlocation =
+		list_entry(op, struct afs_vlocation, upd_op);
 	unsigned tmp;
 	int ret;
 
-	_enter("%s",vlocation->vldb.name);
+	_enter("%s", vlocation->vldb.name);
 
-	ret = afs_rxvl_get_entry_by_id_async2(op,&vldb);
+	ret = afs_rxvl_get_entry_by_id_async2(op, &vldb);
 	switch (ret) {
 	case -EAGAIN:
 		_leave(" [unfinished]");
 		return;
 
 	case 0:
-		_debug("END VL UPDATE: %d\n",ret);
+		_debug("END VL UPDATE: %d\n", ret);
 		vlocation->valid = 1;
 
 		_debug("Done VL Lookup: %02x { %08x(%x) %08x(%x) %08x(%x) }",
 		       vldb.vidmask,
-		       ntohl(vldb.servers[0].s_addr),vldb.srvtmask[0],
-		       ntohl(vldb.servers[1].s_addr),vldb.srvtmask[1],
-		       ntohl(vldb.servers[2].s_addr),vldb.srvtmask[2]
+		       ntohl(vldb.servers[0].s_addr), vldb.srvtmask[0],
+		       ntohl(vldb.servers[1].s_addr), vldb.srvtmask[1],
+		       ntohl(vldb.servers[2].s_addr), vldb.srvtmask[2]
 		       );
 
-		_debug("Vids: %08x %08x %08x",vldb.vid[0],vldb.vid[1],vldb.vid[2]);
+		_debug("Vids: %08x %08x %08x",
+		       vldb.vid[0], vldb.vid[1], vldb.vid[2]);
 
-		afs_vlocation_update_abandon(vlocation,AFS_VLUPD_SLEEP,0);
+		afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0);
 
 		down_write(&vlocation->cell->vl_sem);
 
 		/* actually update the cache */
-		if (strncmp(vldb.name,vlocation->vldb.name,sizeof(vlocation->vldb.name))!=0)
-			printk("kAFS: name of volume '%s' changed to '%s' on server\n",
-			       vlocation->vldb.name,vldb.name);
+		if (strncmp(vldb.name, vlocation->vldb.name,
+			    sizeof(vlocation->vldb.name)) != 0)
+			printk("kAFS: name of volume '%s'"
+			       " changed to '%s' on server\n",
+			       vlocation->vldb.name, vldb.name);
 
-		memcpy(&vlocation->vldb,&vldb,sizeof(vlocation->vldb));
+		memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb));
 
 #if 0
-		/* add volume entry to local cache */
-		ret = afsc_update_vlocation(vlocation);
+		/* TODO update volume entry in local cache */
 #endif
 
 		up_write(&vlocation->cell->vl_sem);
 
-		if (ret<0)
-			printk("kAFS: failed to update local cache: %d\n",ret);
+		if (ret < 0)
+			printk("kAFS: failed to update local cache: %d\n", ret);
 
-		afs_kafstimod_add_timer(&vlocation->upd_timer,AFS_VLDB_TIMEOUT);
+		afs_kafstimod_add_timer(&vlocation->upd_timer,
+					AFS_VLDB_TIMEOUT);
 		afs_put_vlocation(vlocation);
 		_leave(" [found]");
 		return;
@@ -763,11 +789,12 @@
 		/* the server is locked - retry in a very short while */
 	case -EBUSY:
 		vlocation->upd_busy_cnt++;
-		if (vlocation->upd_busy_cnt>3)
+		if (vlocation->upd_busy_cnt > 3)
 			goto try_next; /* too many retries */
 
-		afs_vlocation_update_abandon(vlocation,AFS_VLUPD_BUSYSLEEP,0);
-		afs_kafstimod_add_timer(&vlocation->upd_timer,HZ/2);
+		afs_vlocation_update_abandon(vlocation,
+					     AFS_VLUPD_BUSYSLEEP, 0);
+		afs_kafstimod_add_timer(&vlocation->upd_timer, HZ / 2);
 		afs_put_vlocation(vlocation);
 		_leave(" [busy]");
 		return;
@@ -781,7 +808,8 @@
 		 */
 		if (vlocation->upd_curr_svix == vlocation->cell->vl_curr_svix)
 			vlocation->cell->vl_curr_svix =
-				vlocation->cell->vl_curr_svix % vlocation->cell->vl_naddrs;
+				vlocation->cell->vl_curr_svix %
+				vlocation->cell->vl_naddrs;
 
 	case -EBADRQC:
 	case -EINVAL:
@@ -802,26 +830,30 @@
 	vlocation->upd_op.server = NULL;
 
 	tmp = vlocation->cell->vl_naddrs;
-	if (tmp==0)
+	if (tmp == 0)
 		goto abandon;
 
 	vlocation->upd_curr_svix++;
-	if (vlocation->upd_curr_svix >= tmp) vlocation->upd_curr_svix = 0;
-	if (vlocation->upd_first_svix >= tmp) vlocation->upd_first_svix = tmp - 1;
+	if (vlocation->upd_curr_svix >= tmp)
+		vlocation->upd_curr_svix = 0;
+	if (vlocation->upd_first_svix >= tmp)
+		vlocation->upd_first_svix = tmp - 1;
 
 	/* move to the next server */
-	if (vlocation->upd_curr_svix!=vlocation->upd_first_svix) {
+	if (vlocation->upd_curr_svix != vlocation->upd_first_svix) {
 		afs_vlocation_update_begin(vlocation);
 		_leave(" [next]");
 		return;
 	}
 
 	/* run out of servers to try - was the volume rejected? */
-	if (vlocation->upd_rej_cnt>0) {
-		printk("kAFS: Active volume no longer valid '%s'\n",vlocation->vldb.name);
+	if (vlocation->upd_rej_cnt > 0) {
+		printk("kAFS: Active volume no longer valid '%s'\n",
+		       vlocation->vldb.name);
 		vlocation->valid = 0;
-		afs_vlocation_update_abandon(vlocation,AFS_VLUPD_SLEEP,0);
-		afs_kafstimod_add_timer(&vlocation->upd_timer,AFS_VLDB_TIMEOUT);
+		afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0);
+		afs_kafstimod_add_timer(&vlocation->upd_timer,
+					AFS_VLDB_TIMEOUT);
 		afs_put_vlocation(vlocation);
 		_leave(" [invalidated]");
 		return;
@@ -829,8 +861,8 @@
 
 	/* abandon the update */
  abandon:
-	afs_vlocation_update_abandon(vlocation,AFS_VLUPD_SLEEP,ret);
-	afs_kafstimod_add_timer(&vlocation->upd_timer,HZ*10);
+	afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret);
+	afs_kafstimod_add_timer(&vlocation->upd_timer, HZ * 10);
 	afs_put_vlocation(vlocation);
 	_leave(" [abandoned]");
 
@@ -842,11 +874,12 @@
  * - called in kafsasyncd context when it's dying due to rmmod
  * - the call has already been aborted and put()'d
  */
-static void afs_vlocation_update_discard(afs_async_op_t *op)
+static void afs_vlocation_update_discard(struct afs_async_op *op)
 {
-	afs_vlocation_t *vlocation = list_entry(op,afs_vlocation_t,upd_op);
+	struct afs_vlocation *vlocation =
+		list_entry(op, struct afs_vlocation, upd_op);
 
-	_enter("%s",vlocation->vldb.name);
+	_enter("%s", vlocation->vldb.name);
 
 	afs_put_server(op->server);
 	op->server = NULL;
@@ -870,11 +903,11 @@
 
 	_enter("{%s},{%s}", vlocation->vldb.name, vldb->name);
 
-	if (strncmp(vlocation->vldb.name,
-		    vldb->name,
-		    sizeof(vldb->name)) == 0) {
+	if (strncmp(vlocation->vldb.name, vldb->name, sizeof(vldb->name)) == 0
+	    ) {
 		if (!vlocation->valid ||
-		    vlocation->vldb.rtime == vldb->rtime) {
+		    vlocation->vldb.rtime == vldb->rtime
+		    ) {
 			struct_cpy(&vlocation->vldb, vldb);
 			vlocation->valid = 1;
 			_leave(" = SUCCESS [c->m]");

Index: vlclient.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/vlclient.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- vlclient.h	4 Jul 2003 15:26:31 -0000	1.5
+++ vlclient.h	10 Sep 2003 13:32:37 -0000	1.6
@@ -72,25 +72,25 @@
 };
 
 /* probe a volume location server to see if it is still alive */
-extern int afs_rxvl_probe(afs_server_t *server, int alloc_flags);
+extern int afs_rxvl_probe(struct afs_server *server, int alloc_flags);
 
 /* look up a volume location database entry by name */
-extern int afs_rxvl_get_entry_by_name(afs_server_t *server,
+extern int afs_rxvl_get_entry_by_name(struct afs_server *server,
 				      const char *volname,
 				      unsigned volnamesz,
 				      struct afs_cache_vlocation *entry);
 
 /* look up a volume location database entry by ID */
-extern int afs_rxvl_get_entry_by_id(afs_server_t *server,
+extern int afs_rxvl_get_entry_by_id(struct afs_server *server,
 				    afs_volid_t	volid,
 				    afs_voltype_t voltype,
 				    struct afs_cache_vlocation *entry);
 
-extern int afs_rxvl_get_entry_by_id_async(afs_async_op_t *op,
+extern int afs_rxvl_get_entry_by_id_async(struct afs_async_op *op,
 					  afs_volid_t volid,
 					  afs_voltype_t voltype);
 
-extern int afs_rxvl_get_entry_by_id_async2(afs_async_op_t *op,
+extern int afs_rxvl_get_entry_by_id_async2(struct afs_async_op *op,
 					   struct afs_cache_vlocation *entry);
 
 #endif /* _LINUX_AFS_VLCLIENT_H */

Index: vlclient.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/vlclient.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- vlclient.c	4 Jul 2003 15:26:31 -0000	1.7
+++ vlclient.c	10 Sep 2003 13:32:37 -0000	1.8
@@ -39,7 +39,8 @@
 {
 	int err;
 
-	_enter("{%u,%u,%d}",call->app_err_state,call->app_abort_code,call->app_errno);
+	_enter("{%u,%u,%d}",
+	       call->app_err_state, call->app_abort_code, call->app_errno);
 
 	switch (call->app_err_state) {
 	case RXRPC_ESTATE_LOCAL_ABORT:
@@ -92,10 +93,8 @@
 /*
  * probe a volume location server to see if it is still alive
  */
-int afs_rxvl_probe(afs_server_t *server, int alloc_flags)
+int afs_rxvl_probe(struct afs_server *server, int alloc_flags)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
 	struct rxrpc_connection *conn;
 	struct rxrpc_call *call;
 	struct iovec piov[1];
@@ -103,21 +102,23 @@
 	int ret;
 	u32 param[1];
 
+	DECLARE_WAITQUEUE(myself, current);
+
 	/* get hold of the vlserver connection */
-	ret = afs_server_get_vlconn(server,&conn);
-	if (ret<0)
+	ret = afs_server_get_vlconn(server, &conn);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(conn,NULL,NULL,afs_rxvl_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxvl_aemap, &call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = VLPROBE;
 
 	/* we want to get event notifications from the call */
-	add_wait_queue(&call->waitq,&myself);
+	add_wait_queue(&call->waitq, &myself);
 
 	/* marshall the parameters */
 	param[0] = htonl(VLPROBE);
@@ -125,14 +126,15 @@
 	piov[0].iov_base = param;
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,1,piov,RXRPC_LAST_PACKET,alloc_flags,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET,
+				    alloc_flags, 0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
 	for (;;) {
 		set_current_state(TASK_INTERRUPTIBLE);
-		if (call->app_call_state!=RXRPC_CSTATE_CLNT_RCV_REPLY ||
+		if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
 		    signal_pending(current))
 			break;
 		schedule();
@@ -158,12 +160,12 @@
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 
  out_unwait:
 	set_current_state(TASK_RUNNING);
-	remove_wait_queue(&call->waitq,&myself);
+	remove_wait_queue(&call->waitq, &myself);
 	rxrpc_put_call(call);
  out_put_conn:
 	rxrpc_put_connection(conn);
@@ -176,10 +178,12 @@
 /*
  * look up a volume location database entry by name
  */
-int afs_rxvl_get_entry_by_name(afs_server_t *server, const char *volname, unsigned volnamesz,
+int afs_rxvl_get_entry_by_name(struct afs_server *server,
+			       const char *volname,
+			       unsigned volnamesz,
 			       struct afs_cache_vlocation *entry)
 {
-	DECLARE_WAITQUEUE(myself,current);
+	DECLARE_WAITQUEUE(myself, current);
 
 	struct rxrpc_connection *conn;
 	struct rxrpc_call *call;
@@ -195,7 +199,7 @@
 
 	/* get hold of the vlserver connection */
 	ret = afs_server_get_vlconn(server, &conn);
-	if (ret<0)
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
@@ -211,7 +215,7 @@
 
 	/* marshall the parameters */
 	piov[1].iov_len = volnamesz;
-	piov[1].iov_base = (char*) volname;
+	piov[1].iov_base = (char *) volname;
 
 	zero = 0;
 	piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
@@ -224,14 +228,17 @@
 	piov[0].iov_base = param;
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS, 0, &sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
 	bp = rxrpc_call_alloc_scratch(call, 384);
 
-	ret = rxrpc_call_read_data(call, bp, 384, RXRPC_CALL_READ_BLOCK|RXRPC_CALL_READ_ALL);
+	ret = rxrpc_call_read_data(call, bp, 384,
+				   RXRPC_CALL_READ_BLOCK |
+				   RXRPC_CALL_READ_ALL);
 	if (ret < 0) {
 		if (ret == -ECONNABORTED) {
 			ret = call->app_errno;
@@ -241,23 +248,26 @@
 	}
 
 	/* unmarshall the reply */
-	for (loop=0; loop<64; loop++)
+	for (loop = 0; loop < 64; loop++)
 		entry->name[loop] = ntohl(*bp++);
 	bp++; /* final NUL */
 
 	bp++; /* type */
 	entry->nservers = ntohl(*bp++);
 
-	for (loop=0; loop<8; loop++)
+	for (loop = 0; loop < 8; loop++)
 		entry->servers[loop].s_addr = *bp++;
 
 	bp += 8; /* partition IDs */
 
-	for (loop=0; loop<8; loop++) {
+	for (loop = 0; loop < 8; loop++) {
 		tmp = ntohl(*bp++);
-		if (tmp & AFS_VLSF_RWVOL  ) entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
-		if (tmp & AFS_VLSF_ROVOL  ) entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
-		if (tmp & AFS_VLSF_BACKVOL) entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
+		if (tmp & AFS_VLSF_RWVOL)
+			entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
+		if (tmp & AFS_VLSF_ROVOL)
+			entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
+		if (tmp & AFS_VLSF_BACKVOL)
+			entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
 	}
 
 	entry->vid[0] = ntohl(*bp++);
@@ -267,9 +277,12 @@
 	bp++; /* clone ID */
 
 	tmp = ntohl(*bp++); /* flags */
-	if (tmp & AFS_VLF_RWEXISTS  ) entry->vidmask |= AFS_VOL_VTM_RW;
-	if (tmp & AFS_VLF_ROEXISTS  ) entry->vidmask |= AFS_VOL_VTM_RO;
-	if (tmp & AFS_VLF_BACKEXISTS) entry->vidmask |= AFS_VOL_VTM_BAK;
+	if (tmp & AFS_VLF_RWEXISTS)
+		entry->vidmask |= AFS_VOL_VTM_RW;
+	if (tmp & AFS_VLF_ROEXISTS)
+		entry->vidmask |= AFS_VOL_VTM_RO;
+	if (tmp & AFS_VLF_BACKEXISTS)
+		entry->vidmask |= AFS_VOL_VTM_BAK;
 
 	ret = -ENOMEDIUM;
 	if (!entry->vidmask)
@@ -291,7 +304,7 @@
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 	goto out_unwait;
 } /* end afs_rxvl_get_entry_by_name() */
@@ -300,12 +313,12 @@
 /*
  * look up a volume location database entry by ID
  */
-int afs_rxvl_get_entry_by_id(afs_server_t *server,
+int afs_rxvl_get_entry_by_id(struct afs_server *server,
 			     afs_volid_t volid,
 			     afs_voltype_t voltype,
 			     struct afs_cache_vlocation *entry)
 {
-	DECLARE_WAITQUEUE(myself,current);
+	DECLARE_WAITQUEUE(myself, current);
 
 	struct rxrpc_connection *conn;
 	struct rxrpc_call *call;
@@ -315,25 +328,25 @@
 	int ret, loop;
 	u32 *bp, param[3];
 
-	_enter(",%x,%d,",volid,voltype);
+	_enter(",%x,%d,", volid, voltype);
 
-	memset(entry,0,sizeof(*entry));
+	memset(entry, 0, sizeof(*entry));
 
 	/* get hold of the vlserver connection */
-	ret = afs_server_get_vlconn(server,&conn);
-	if (ret<0)
+	ret = afs_server_get_vlconn(server, &conn);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(conn,NULL,NULL,afs_rxvl_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxvl_aemap, &call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = VLGETENTRYBYID;
 
 	/* we want to get event notifications from the call */
-	add_wait_queue(&call->waitq,&myself);
+	add_wait_queue(&call->waitq, &myself);
 
 	/* marshall the parameters */
 	param[0] = htonl(VLGETENTRYBYID);
@@ -344,16 +357,19 @@
 	piov[0].iov_base = param;
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,1,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
-	bp = rxrpc_call_alloc_scratch(call,384);
+	bp = rxrpc_call_alloc_scratch(call, 384);
 
-	ret = rxrpc_call_read_data(call,bp,384,RXRPC_CALL_READ_BLOCK|RXRPC_CALL_READ_ALL);
-	if (ret<0) {
-		if (ret==-ECONNABORTED) {
+	ret = rxrpc_call_read_data(call, bp, 384,
+				   RXRPC_CALL_READ_BLOCK |
+				   RXRPC_CALL_READ_ALL);
+	if (ret < 0) {
+		if (ret == -ECONNABORTED) {
 			ret = call->app_errno;
 			goto out_unwait;
 		}
@@ -361,23 +377,26 @@
 	}
 
 	/* unmarshall the reply */
-	for (loop=0; loop<64; loop++)
+	for (loop = 0; loop < 64; loop++)
 		entry->name[loop] = ntohl(*bp++);
 	bp++; /* final NUL */
 
 	bp++; /* type */
 	entry->nservers = ntohl(*bp++);
 
-	for (loop=0; loop<8; loop++)
+	for (loop = 0; loop < 8; loop++)
 		entry->servers[loop].s_addr = *bp++;
 
 	bp += 8; /* partition IDs */
 
-	for (loop=0; loop<8; loop++) {
+	for (loop = 0; loop < 8; loop++) {
 		tmp = ntohl(*bp++);
-		if (tmp & AFS_VLSF_RWVOL  ) entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
-		if (tmp & AFS_VLSF_ROVOL  ) entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
-		if (tmp & AFS_VLSF_BACKVOL) entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
+		if (tmp & AFS_VLSF_RWVOL)
+			entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
+		if (tmp & AFS_VLSF_ROVOL)
+			entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
+		if (tmp & AFS_VLSF_BACKVOL)
+			entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
 	}
 
 	entry->vid[0] = ntohl(*bp++);
@@ -387,9 +406,12 @@
 	bp++; /* clone ID */
 
 	tmp = ntohl(*bp++); /* flags */
-	if (tmp & AFS_VLF_RWEXISTS  ) entry->vidmask |= AFS_VOL_VTM_RW;
-	if (tmp & AFS_VLF_ROEXISTS  ) entry->vidmask |= AFS_VOL_VTM_RO;
-	if (tmp & AFS_VLF_BACKEXISTS) entry->vidmask |= AFS_VOL_VTM_BAK;
+	if (tmp & AFS_VLF_RWEXISTS)
+		entry->vidmask |= AFS_VOL_VTM_RW;
+	if (tmp & AFS_VLF_ROEXISTS)
+		entry->vidmask |= AFS_VOL_VTM_RO;
+	if (tmp & AFS_VLF_BACKEXISTS)
+		entry->vidmask |= AFS_VOL_VTM_BAK;
 
 	ret = -ENOMEDIUM;
 	if (!entry->vidmask)
@@ -412,17 +434,17 @@
 
  out_unwait:
 	set_current_state(TASK_RUNNING);
-	remove_wait_queue(&call->waitq,&myself);
+	remove_wait_queue(&call->waitq, &myself);
 	rxrpc_put_call(call);
  out_put_conn:
 	rxrpc_put_connection(conn);
  out:
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 	goto out_unwait;
 } /* end afs_rxvl_get_entry_by_id() */
@@ -431,7 +453,7 @@
 /*
  * look up a volume location database entry by ID asynchronously
  */
-int afs_rxvl_get_entry_by_id_async(afs_async_op_t *op,
+int afs_rxvl_get_entry_by_id_async(struct afs_async_op *op,
 				   afs_volid_t volid,
 				   afs_voltype_t voltype)
 {
@@ -442,12 +464,12 @@
 	int ret;
 	u32 param[3];
 
-	_enter(",%x,%d,",volid,voltype);
+	_enter(",%x,%d,", volid, voltype);
 
 	/* get hold of the vlserver connection */
-	ret = afs_server_get_vlconn(op->server,&conn);
-	if (ret<0) {
-		_leave(" = %d",ret);
+	ret = afs_server_get_vlconn(op->server, &conn);
+	if (ret < 0) {
+		_leave(" = %d", ret);
 		return ret;
 	}
 
@@ -459,9 +481,9 @@
 				&op->call);
 	rxrpc_put_connection(conn);
 
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
-		_leave(" = %d",ret);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
+		_leave(" = %d", ret);
 		return ret;
 	}
 
@@ -483,18 +505,19 @@
 	piov[0].iov_base = param;
 
 	/* allocate result read buffer in scratch space */
-	call->app_scr_ptr = rxrpc_call_alloc_scratch(op->call,384);
+	call->app_scr_ptr = rxrpc_call_alloc_scratch(op->call, 384);
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,1,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0) {
-		rxrpc_call_abort(call,ret); /* handle from kafsasyncd */
+	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0) {
+		rxrpc_call_abort(call, ret); /* handle from kafsasyncd */
 		ret = 0;
 		goto out;
 	}
 
 	/* wait for the reply to completely arrive */
-	ret = rxrpc_call_read_data(call,call->app_scr_ptr,384,0);
+	ret = rxrpc_call_read_data(call, call->app_scr_ptr, 384, 0);
 	switch (ret) {
 	case 0:
 	case -EAGAIN:
@@ -503,14 +526,14 @@
 		break;	/* all handled by kafsasyncd */
 
 	default:
-		rxrpc_call_abort(call,ret); /* force kafsasyncd to handle it */
+		rxrpc_call_abort(call, ret); /* make kafsasyncd handle it */
 		ret = 0;
 		break;
 	}
 
  out:
 	rxrpc_put_call(call);
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_rxvl_get_entry_by_id_async() */
@@ -519,40 +542,43 @@
 /*
  * attend to the asynchronous get VLDB entry by ID
  */
-int afs_rxvl_get_entry_by_id_async2(afs_async_op_t *op,
+int afs_rxvl_get_entry_by_id_async2(struct afs_async_op *op,
 				    struct afs_cache_vlocation *entry)
 {
 	unsigned *bp, tmp;
 	int loop, ret;
 
-	_enter("{op=%p cst=%u}",op,op->call->app_call_state);
+	_enter("{op=%p cst=%u}", op, op->call->app_call_state);
 
-	memset(entry,0,sizeof(*entry));
+	memset(entry, 0, sizeof(*entry));
 
-	if (op->call->app_call_state==RXRPC_CSTATE_COMPLETE) {
+	if (op->call->app_call_state == RXRPC_CSTATE_COMPLETE) {
 		/* operation finished */
 		afs_kafsasyncd_terminate_op(op);
 
 		bp = op->call->app_scr_ptr;
 
 		/* unmarshall the reply */
-		for (loop=0; loop<64; loop++)
+		for (loop = 0; loop < 64; loop++)
 			entry->name[loop] = ntohl(*bp++);
 		bp++; /* final NUL */
 
 		bp++; /* type */
 		entry->nservers = ntohl(*bp++);
 
-		for (loop=0; loop<8; loop++)
+		for (loop = 0; loop < 8; loop++)
 			entry->servers[loop].s_addr = *bp++;
 
 		bp += 8; /* partition IDs */
 
-		for (loop=0; loop<8; loop++) {
+		for (loop = 0; loop < 8; loop++) {
 			tmp = ntohl(*bp++);
-			if (tmp & AFS_VLSF_RWVOL  ) entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
-			if (tmp & AFS_VLSF_ROVOL  ) entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
-			if (tmp & AFS_VLSF_BACKVOL) entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
+			if (tmp & AFS_VLSF_RWVOL)
+				entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
+			if (tmp & AFS_VLSF_ROVOL)
+				entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
+			if (tmp & AFS_VLSF_BACKVOL)
+				entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
 		}
 
 		entry->vid[0] = ntohl(*bp++);
@@ -562,13 +588,16 @@
 		bp++; /* clone ID */
 
 		tmp = ntohl(*bp++); /* flags */
-		if (tmp & AFS_VLF_RWEXISTS  ) entry->vidmask |= AFS_VOL_VTM_RW;
-		if (tmp & AFS_VLF_ROEXISTS  ) entry->vidmask |= AFS_VOL_VTM_RO;
-		if (tmp & AFS_VLF_BACKEXISTS) entry->vidmask |= AFS_VOL_VTM_BAK;
+		if (tmp & AFS_VLF_RWEXISTS)
+			entry->vidmask |= AFS_VOL_VTM_RW;
+		if (tmp & AFS_VLF_ROEXISTS)
+			entry->vidmask |= AFS_VOL_VTM_RO;
+		if (tmp & AFS_VLF_BACKEXISTS)
+			entry->vidmask |= AFS_VOL_VTM_BAK;
 
 		ret = -ENOMEDIUM;
 		if (!entry->vidmask) {
-			rxrpc_call_abort(op->call,ret);
+			rxrpc_call_abort(op->call, ret);
 			goto done;
 		}
 
@@ -589,7 +618,7 @@
 		goto done;
 	}
 
-	if (op->call->app_call_state==RXRPC_CSTATE_ERROR) {
+	if (op->call->app_call_state == RXRPC_CSTATE_ERROR) {
 		/* operation error */
 		ret = op->call->app_errno;
 		goto done;
@@ -601,7 +630,7 @@
  done:
 	rxrpc_put_call(op->call);
 	op->call = NULL;
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_rxvl_get_entry_by_id_async2() */
 
@@ -612,9 +641,9 @@
  */
 static void afs_rxvl_get_entry_by_id_attn(struct rxrpc_call *call)
 {
-	afs_async_op_t *op = call->app_user;
+	struct afs_async_op *op = call->app_user;
 
-	_enter("{op=%p cst=%u}",op,call->app_call_state);
+	_enter("{op=%p cst=%u}", op, call->app_call_state);
 
 	switch (call->app_call_state) {
 	case RXRPC_CSTATE_COMPLETE:
@@ -624,7 +653,7 @@
 		if (call->app_async_read)
 			break;
 	case RXRPC_CSTATE_CLNT_GOT_REPLY:
-		if (call->app_read_count==0)
+		if (call->app_read_count == 0)
 			break;
 		printk("kAFS: Reply bigger than expected"
 		       " {cst=%u asyn=%d mark=%Zu rdy=%Zu pr=%u%s}",
@@ -635,7 +664,7 @@
 		       call->pkt_rcv_count,
 		       call->app_last_rcv ? " last" : "");
 
-		rxrpc_call_abort(call,-EBADMSG);
+		rxrpc_call_abort(call, -EBADMSG);
 		break;
 	default:
 		BUG();
@@ -652,9 +681,9 @@
  */
 static void afs_rxvl_get_entry_by_id_error(struct rxrpc_call *call)
 {
-	afs_async_op_t *op = call->app_user;
+	struct afs_async_op *op = call->app_user;
 
-	_enter("{op=%p cst=%u}",op,call->app_call_state);
+	_enter("{op=%p cst=%u}", op, call->app_call_state);
 
 	afs_kafsasyncd_attend_op(op);

Index: types.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/types.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- types.h	6 Jun 2003 08:33:37 -0000	1.5
+++ types.h	10 Sep 2003 13:32:37 -0000	1.6
@@ -20,21 +20,6 @@
 typedef unsigned			afs_vnodeid_t;
 typedef unsigned long long		afs_dataversion_t;
 
-typedef struct afs_async_op		afs_async_op_t;
-typedef struct afs_callback		afs_callback_t;
-typedef struct afs_cell			afs_cell_t;
-typedef struct afs_fid			afs_fid_t;
-typedef struct afs_file_status		afs_file_status_t;
-typedef struct afs_server		afs_server_t;
-typedef struct afs_timer		afs_timer_t;
-typedef struct afs_vlocation		afs_vlocation_t;
-typedef struct afs_vnode		afs_vnode_t;
-typedef struct afs_volsync		afs_volsync_t;
-typedef struct afs_volume		afs_volume_t;
-typedef struct afs_volume_info		afs_volume_info_t;
-
-typedef struct afsvl_dbentry		afsvl_dbentry_t;
-
 typedef enum {
 	AFSVL_RWVOL,			/* read/write volume */
 	AFSVL_ROVOL,			/* read-only volume */
@@ -52,6 +37,9 @@
 
 #ifdef __KERNEL__
 
+struct afs_cell;
+struct afs_vnode;
+
 /*****************************************************************************/
 /*
  * AFS file identifier
@@ -76,8 +64,8 @@
 
 struct afs_callback
 {
-	afs_server_t		*server;	/* server that made the promise */
-	afs_fid_t		fid;		/* file identifier */
+	struct afs_server	*server;	/* server that made the promise */
+	struct afs_fid		fid;		/* file identifier */
 	unsigned		version;	/* callback version */
 	unsigned		expiry;		/* time at which expires */
 	afs_callback_type_t	type;		/* type of callback */
@@ -120,7 +108,7 @@
 	unsigned		caller_access;	/* access rights for authenticated caller */
 	unsigned		anon_access;	/* access rights for unauthenticated caller */
 	umode_t			mode;		/* UNIX mode */
-	afs_fid_t		parent;		/* parent file ID */
+	struct afs_fid		parent;		/* parent file ID */
 	time_t			mtime_client;	/* last time client changed data */
 	time_t			mtime_server;	/* last time server changed data */
 };

Index: super.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/super.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -r1.11 -r1.12
--- super.c	10 Sep 2003 08:23:15 -0000	1.11
+++ super.c	10 Sep 2003 13:32:37 -0000	1.12
@@ -94,7 +94,7 @@
 
 	ret = -ENOMEM;
 	afs_inode_cachep = kmem_cache_create("afs_inode_cache",
-					     sizeof(afs_vnode_t),
+					     sizeof(struct afs_vnode),
 					     0,
 					     SLAB_HWCACHE_ALIGN,
 					     afs_i_init_once,
@@ -164,8 +164,8 @@
 /*****************************************************************************/
 /*
  * parse the mount options
- * - this function has been shamelessly adapted from the ext3 fs which shamelessly adapted it from
- *   the msdos fs
+ * - this function has been shamelessly adapted from the ext3 fs which
+ *   shamelessly adapted it from the msdos fs
  */
 static int afs_super_parse_options(struct afs_mount_params *params,
 				   char *options,
@@ -243,9 +243,9 @@
 {
 	struct afs_mount_params *params = data;
 	struct afs_super_info *as = NULL;
+	struct afs_fid fid;
 	struct dentry *root = NULL;
 	struct inode *inode = NULL;
-	afs_fid_t fid;
 	int ret;
 
 	kenter("");
@@ -395,7 +395,7 @@
 static void afs_i_init_once(void *_vnode, kmem_cache_t *cachep,
 			    unsigned long flags)
 {
-	afs_vnode_t *vnode = (afs_vnode_t *) _vnode;
+	struct afs_vnode *vnode = (struct afs_vnode *) _vnode;
 
 	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
 	    SLAB_CTOR_CONSTRUCTOR) {
@@ -417,9 +417,9 @@
  */
 static struct inode *afs_alloc_inode(struct super_block *sb)
 {
-	afs_vnode_t *vnode;
+	struct afs_vnode *vnode;
 
-	vnode = (afs_vnode_t *)
+	vnode = (struct afs_vnode *)
 		kmem_cache_alloc(afs_inode_cachep, SLAB_KERNEL);
 	if (!vnode)
 		return NULL;

Index: server.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/server.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -r1.1.1.1 -r1.2
--- server.h	19 Jun 2002 13:34:06 -0000	1.1.1.1
+++ server.h	10 Sep 2003 13:32:37 -0000	1.2
@@ -26,10 +26,10 @@
 struct afs_server
 {
 	atomic_t		usage;
-	afs_cell_t		*cell;		/* cell in which server resides */
+	struct afs_cell		*cell;		/* cell in which server resides */
 	struct list_head	link;		/* link in cell's server list */
 	struct rw_semaphore	sem;		/* access lock */
-	afs_timer_t		timeout;	/* graveyard timeout */
+	struct afs_timer	timeout;	/* graveyard timeout */
 	struct in_addr		addr;		/* server address */
 	struct rxrpc_peer	*peer;		/* peer record for this server */
 	struct rxrpc_connection	*vlserver;	/* connection to the volume location service */
@@ -50,20 +50,25 @@
 	spinlock_t		cb_lock;	/* access lock */
 };
 
-extern int afs_server_lookup(afs_cell_t *cell, const struct in_addr *addr, afs_server_t **_server);
+extern int afs_server_lookup(struct afs_cell *cell,
+			     const struct in_addr *addr,
+			     struct afs_server **_server);
 
 #define afs_get_server(S) do { atomic_inc(&(S)->usage); } while(0)
 
-extern void afs_put_server(afs_server_t *server);
-extern void afs_server_do_timeout(afs_server_t *server);
+extern void afs_put_server(struct afs_server *server);
+extern void afs_server_do_timeout(struct afs_server *server);
 
-extern int afs_server_find_by_peer(const struct rxrpc_peer *peer, afs_server_t **_server);
+extern int afs_server_find_by_peer(const struct rxrpc_peer *peer,
+				   struct afs_server **_server);
 
-extern int afs_server_get_vlconn(afs_server_t *server, struct rxrpc_connection **_conn);
+extern int afs_server_get_vlconn(struct afs_server *server,
+				 struct rxrpc_connection **_conn);
 
-static inline afs_server_t *afs_server_get_from_peer(struct rxrpc_peer *peer)
+static inline
+struct afs_server *afs_server_get_from_peer(struct rxrpc_peer *peer)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 
 	spin_lock(&afs_server_peer_lock);
 	server = peer->user;
@@ -88,10 +93,10 @@
 	int			errno;		/* error number if nconn==-1 */
 };
 
-extern int afs_server_request_callslot(afs_server_t *server,
+extern int afs_server_request_callslot(struct afs_server *server,
 				       struct afs_server_callslot *callslot);
 
-extern void afs_server_release_callslot(afs_server_t *server,
+extern void afs_server_release_callslot(struct afs_server *server,
 					struct afs_server_callslot *callslot);
 
 #endif /* _LINUX_AFS_SERVER_H */

Index: server.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/server.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- server.c	4 Jul 2003 15:26:31 -0000	1.4
+++ server.c	10 Sep 2003 13:32:37 -0000	1.5
@@ -26,11 +26,13 @@
 #define FS_SERVICE_ID		1	/* AFS Volume Location Service ID */
 #define VL_SERVICE_ID		52	/* AFS Volume Location Service ID */
 
-static void __afs_server_timeout(afs_timer_t *timer)
+static void __afs_server_timeout(struct afs_timer *timer)
 {
-	afs_server_t *server = list_entry(timer,afs_server_t,timeout);
+	struct afs_server *server =
+		list_entry(timer, struct afs_server, timeout);
 
-	_debug("SERVER TIMEOUT [%p{u=%d}]",server,atomic_read(&server->usage));
+	_debug("SERVER TIMEOUT [%p{u=%d}]",
+	       server, atomic_read(&server->usage));
 
 	afs_server_do_timeout(server);
 }
@@ -44,23 +46,23 @@
  * lookup a server record in a cell
  * - TODO: search the cell's server list
  */
-int afs_server_lookup(afs_cell_t *cell, const struct in_addr *addr, afs_server_t **_server)
+int afs_server_lookup(struct afs_cell *cell, const struct in_addr *addr,
+		      struct afs_server **_server)
 {
-	struct list_head *_p;
-	afs_server_t *server, *active, *zombie;
+	struct afs_server *server, *active, *zombie;
 	int loop;
 
-	_enter("%p,%08x,",cell,ntohl(addr->s_addr));
+	_enter("%p,%08x,", cell, ntohl(addr->s_addr));
 
 	/* allocate and initialise a server record */
-	server = kmalloc(sizeof(afs_server_t),GFP_KERNEL);
+	server = kmalloc(sizeof(struct afs_server), GFP_KERNEL);
 	if (!server) {
 		_leave(" = -ENOMEM");
 		return -ENOMEM;
 	}
 
-	memset(server,0,sizeof(afs_server_t));
-	atomic_set(&server->usage,1);
+	memset(server, 0, sizeof(struct afs_server));
+	atomic_set(&server->usage, 1);
 
 	INIT_LIST_HEAD(&server->link);
 	init_rwsem(&server->sem);
@@ -69,43 +71,39 @@
 	INIT_LIST_HEAD(&server->cb_promises);
 	spin_lock_init(&server->cb_lock);
 
-	for (loop=0; loop<AFS_SERVER_CONN_LIST_SIZE; loop++)
+	for (loop = 0; loop < AFS_SERVER_CONN_LIST_SIZE; loop++)
 		server->fs_conn_cnt[loop] = 4;
 
-	memcpy(&server->addr,addr,sizeof(struct in_addr));
+	memcpy(&server->addr, addr, sizeof(struct in_addr));
 	server->addr.s_addr = addr->s_addr;
 
-	afs_timer_init(&server->timeout,&afs_server_timer_ops);
+	afs_timer_init(&server->timeout, &afs_server_timer_ops);
 
 	/* add to the cell */
 	write_lock(&cell->sv_lock);
 
 	/* check the active list */
-	list_for_each(_p,&cell->sv_list) {
-		active = list_entry(_p,afs_server_t,link);
-
-		if (active->addr.s_addr==addr->s_addr)
+	list_for_each_entry(active, &cell->sv_list, link) {
+		if (active->addr.s_addr == addr->s_addr)
 			goto use_active_server;
 	}
 
 	/* check the inactive list */
 	spin_lock(&cell->sv_gylock);
-	list_for_each(_p,&cell->sv_graveyard) {
-		zombie = list_entry(_p,afs_server_t,link);
-
-		if (zombie->addr.s_addr==addr->s_addr)
+	list_for_each_entry(zombie, &cell->sv_graveyard, link) {
+		if (zombie->addr.s_addr == addr->s_addr)
 			goto resurrect_server;
 	}
 	spin_unlock(&cell->sv_gylock);
 
 	afs_get_cell(cell);
 	server->cell = cell;
-	list_add_tail(&server->link,&cell->sv_list);
+	list_add_tail(&server->link, &cell->sv_list);
 
 	write_unlock(&cell->sv_lock);
 
 	*_server = server;
-	_leave(" = 0 (%p)",server);
+	_leave(" = 0 (%p)", server);
 	return 0;
 
 	/* found a matching active server */
@@ -117,15 +115,16 @@
 	kfree(server);
 
 	*_server = active;
-	_leave(" = 0 (%p)",active);
+	_leave(" = 0 (%p)", active);
 	return 0;
 
-	/* found a matching server in the graveyard, so resurrect it and dispose of the new rec */
+	/* found a matching server in the graveyard, so resurrect it and
+	 * dispose of the new record */
  resurrect_server:
 	_debug("resurrecting server");
 
 	list_del(&zombie->link);
-	list_add_tail(&zombie->link,&cell->sv_list);
+	list_add_tail(&zombie->link, &cell->sv_list);
 	afs_get_server(zombie);
 	afs_kafstimod_del_timer(&zombie->timeout);
 	spin_unlock(&cell->sv_gylock);
@@ -134,7 +133,7 @@
 	kfree(server);
 
 	*_server = zombie;
-	_leave(" = 0 (%p)",zombie);
+	_leave(" = 0 (%p)", zombie);
 	return 0;
 
 } /* end afs_server_lookup() */
@@ -144,22 +143,22 @@
  * destroy a server record
  * - removes from the cell list
  */
-void afs_put_server(afs_server_t *server)
+void afs_put_server(struct afs_server *server)
 {
-	afs_cell_t *cell;
+	struct afs_cell *cell;
 
 	if (!server)
 		return;
 
-	_enter("%p",server);
+	_enter("%p", server);
 
 	cell = server->cell;
 
 	/* sanity check */
-	if (atomic_read(&server->usage)<=0)
-		BUG();
+	BUG_ON(atomic_read(&server->usage) <= 0);
 
-	/* to prevent a race, the decrement and the dequeue must be effectively atomic */
+	/* to prevent a race, the decrement and the dequeue must be effectively
+	 * atomic */
 	write_lock(&cell->sv_lock);
 
 	if (likely(!atomic_dec_and_test(&server->usage))) {
@@ -170,10 +169,10 @@
 
 	spin_lock(&cell->sv_gylock);
 	list_del(&server->link);
-	list_add_tail(&server->link,&cell->sv_graveyard);
+	list_add_tail(&server->link, &cell->sv_graveyard);
 
 	/* time out in 10 secs */
-	afs_kafstimod_add_timer(&server->timeout,10*HZ);
+	afs_kafstimod_add_timer(&server->timeout, 10 * HZ);
 
 	spin_unlock(&cell->sv_gylock);
 	write_unlock(&cell->sv_lock);
@@ -186,21 +185,21 @@
  * timeout server record
  * - removes from the cell's graveyard if the usage count is zero
  */
-void afs_server_do_timeout(afs_server_t *server)
+void afs_server_do_timeout(struct afs_server *server)
 {
 	struct rxrpc_peer *peer;
-	afs_cell_t *cell;
+	struct afs_cell *cell;
 	int loop;
 
-	_enter("%p",server);
+	_enter("%p", server);
 
 	cell = server->cell;
 
-	if (atomic_read(&server->usage)<0) BUG();
+	BUG_ON(atomic_read(&server->usage) < 0);
 
 	/* remove from graveyard if still dead */
 	spin_lock(&cell->vl_gylock);
-	if (atomic_read(&server->usage)==0)
+	if (atomic_read(&server->usage) == 0)
 		list_del_init(&server->link);
 	else
 		server = NULL;
@@ -224,7 +223,7 @@
 	spin_unlock(&afs_server_peer_lock);
 
 	/* finish cleaning up the server */
-	for (loop=AFS_SERVER_CONN_LIST_SIZE-1; loop>=0; loop--)
+	for (loop = AFS_SERVER_CONN_LIST_SIZE - 1; loop >= 0; loop--)
 		if (server->fs_conn[loop])
 			rxrpc_put_connection(server->fs_conn[loop]);
 
@@ -240,7 +239,8 @@
 /*
  * get a callslot on a connection to the fileserver on the specified server
  */
-int afs_server_request_callslot(afs_server_t *server, struct afs_server_callslot *callslot)
+int afs_server_request_callslot(struct afs_server *server,
+				struct afs_server_callslot *callslot)
 {
 	struct afs_server_callslot *pcallslot;
 	struct rxrpc_connection *conn;
@@ -262,10 +262,10 @@
 
 	/* resurrect the server if it's death timeout has expired */
 	if (server->fs_state) {
-		if (time_before(jiffies,server->fs_dead_jif)) {
+		if (time_before(jiffies, server->fs_dead_jif)) {
 			ret = server->fs_state;
 			spin_unlock(&server->fs_lock);
-			_leave(" = %d [still dead]",ret);
+			_leave(" = %d [still dead]", ret);
 			return ret;
 		}
 
@@ -273,8 +273,8 @@
 	}
 
 	/* try and find a connection that has spare callslots */
-	for (nconn=0; nconn<AFS_SERVER_CONN_LIST_SIZE; nconn++) {
-		if (server->fs_conn_cnt[nconn]>0) {
+	for (nconn = 0; nconn < AFS_SERVER_CONN_LIST_SIZE; nconn++) {
+		if (server->fs_conn_cnt[nconn] > 0) {
 			server->fs_conn_cnt[nconn]--;
 			spin_unlock(&server->fs_lock);
 			callslot->nconn = nconn;
@@ -282,9 +282,10 @@
 		}
 	}
 
-	/* none were available - wait interruptibly for one to become available */
+	/* none were available - wait interruptibly for one to become
+	 * available */
 	set_current_state(TASK_INTERRUPTIBLE);
-	list_add_tail(&callslot->link,&server->fs_callq);
+	list_add_tail(&callslot->link, &server->fs_callq);
 	spin_unlock(&server->fs_lock);
 
 	while (!callslot->ready && !signal_pending(current)) {
@@ -303,22 +304,24 @@
 
 	nconn = callslot->nconn;
 
-	/* if interrupted, we must release any slot we also got before returning an error */
+	/* if interrupted, we must release any slot we also got before
+	 * returning an error */
 	if (signal_pending(current)) {
 		ret = -EINTR;
 		goto error_release;
 	}
 
-	/* if we were woken up with an error, then pass that error back to the called */
-	if (nconn<0) {
-		_leave(" = %d",callslot->errno);
+	/* if we were woken up with an error, then pass that error back to the
+	 * called */
+	if (nconn < 0) {
+		_leave(" = %d", callslot->errno);
 		return callslot->errno;
 	}
 
 	/* were we given a connection directly? */
 	if (callslot->conn) {
 		/* yes - use it */
-		_leave(" = 0 (nc=%d)",nconn);
+		_leave(" = 0 (nc=%d)", nconn);
 		return 0;
 	}
 
@@ -347,7 +350,7 @@
 					      NULL,
 					      &server->fs_conn[nconn]);
 
-		if (ret<0)
+		if (ret < 0)
 			goto error_release_upw;
 
 		callslot->conn = server->fs_conn[0];
@@ -364,10 +367,11 @@
 	up_write(&server->sem);
 
  error_release:
-	/* either release the callslot or pass it along to another deserving task */
+	/* either release the callslot or pass it along to another deserving
+	 * task */
 	spin_lock(&server->fs_lock);
 
-	if (nconn<0) {
+	if (nconn < 0) {
 		/* no callslot allocated */
 	}
 	else if (list_empty(&server->fs_callq)) {
@@ -377,13 +381,15 @@
 	}
 	else {
 		/* someone's waiting - dequeue them and wake them up */
-		pcallslot = list_entry(server->fs_callq.next,struct afs_server_callslot,link);
+		pcallslot = list_entry(server->fs_callq.next,
+				       struct afs_server_callslot, link);
 		list_del_init(&pcallslot->link);
 
 		pcallslot->errno = server->fs_state;
 		if (!pcallslot->errno) {
 			/* pass them out callslot details */
-			callslot->conn = xchg(&pcallslot->conn,callslot->conn);
+			callslot->conn = xchg(&pcallslot->conn,
+					      callslot->conn);
 			pcallslot->nconn = nconn;
 			callslot->nconn = nconn = -1;
 		}
@@ -392,10 +398,10 @@
 		spin_unlock(&server->fs_lock);
 	}
 
-	if (callslot->conn) rxrpc_put_connection(callslot->conn);
+	rxrpc_put_connection(callslot->conn);
 	callslot->conn = NULL;
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_server_request_callslot() */
@@ -405,7 +411,8 @@
  * release a callslot back to the server
  * - transfers the RxRPC connection to the next pending callslot if possible
  */
-void afs_server_release_callslot(afs_server_t *server, struct afs_server_callslot *callslot)
+void afs_server_release_callslot(struct afs_server *server,
+				 struct afs_server_callslot *callslot)
 {
 	struct afs_server_callslot *pcallslot;
 
@@ -414,7 +421,7 @@
 	       server->fs_conn_cnt[callslot->nconn],
 	       callslot->nconn);
 
-	if (callslot->nconn<0) BUG();
+	BUG_ON(callslot->nconn < 0);
 
 	spin_lock(&server->fs_lock);
 
@@ -425,13 +432,14 @@
 	}
 	else {
 		/* someone's waiting - dequeue them and wake them up */
-		pcallslot = list_entry(server->fs_callq.next,struct afs_server_callslot,link);
+		pcallslot = list_entry(server->fs_callq.next,
+				       struct afs_server_callslot, link);
 		list_del_init(&pcallslot->link);
 
 		pcallslot->errno = server->fs_state;
 		if (!pcallslot->errno) {
 			/* pass them out callslot details */
-			callslot->conn = xchg(&pcallslot->conn,callslot->conn);
+			callslot->conn = xchg(&pcallslot->conn, callslot->conn);
 			pcallslot->nconn = callslot->nconn;
 			callslot->nconn = -1;
 		}
@@ -441,21 +449,23 @@
 		spin_unlock(&server->fs_lock);
 	}
 
-	if (callslot->conn) rxrpc_put_connection(callslot->conn);
+	rxrpc_put_connection(callslot->conn);
 
 	_leave("");
 } /* end afs_server_release_callslot() */
 
 /*****************************************************************************/
 /*
- * get a handle to a connection to the vlserver (volume location) on the specified server
+ * get a handle to a connection to the vlserver (volume location) on the
+ * specified server
  */
-int afs_server_get_vlconn(afs_server_t *server, struct rxrpc_connection **_conn)
+int afs_server_get_vlconn(struct afs_server *server,
+			  struct rxrpc_connection **_conn)
 {
 	struct rxrpc_connection *conn;
 	int ret;
 
-	_enter("%p,",server);
+	_enter("%p,", server);
 
 	ret = 0;
 	conn = NULL;
@@ -479,7 +489,7 @@
 						      NULL,
 						      &server->vlserver);
 		}
-		if (ret==0) {
+		if (ret == 0) {
 			rxrpc_get_connection(server->vlserver);
 			conn = server->vlserver;
 		}
@@ -487,6 +497,6 @@
 	}
 
 	*_conn = conn;
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_server_get_vlconn() */

Index: proc.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/proc.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- proc.c	16 Oct 2002 11:59:45 -0000	1.4
+++ proc.c	10 Sep 2003 13:32:37 -0000	1.5
@@ -27,7 +27,8 @@
 static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos);
 static void afs_proc_cells_stop(struct seq_file *p, void *v);
 static int afs_proc_cells_show(struct seq_file *m, void *v);
-static ssize_t afs_proc_cells_write(struct file *file, const char *buf, size_t size, loff_t *_pos);
+static ssize_t afs_proc_cells_write(struct file *file, const char *buf,
+				    size_t size, loff_t *_pos);
 
 static struct seq_operations afs_proc_cells_ops = {
 	.start	= afs_proc_cells_start,
@@ -45,9 +46,11 @@
 };
 
 static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file);
-static int afs_proc_cell_volumes_release(struct inode *inode, struct file *file);
+static int afs_proc_cell_volumes_release(struct inode *inode,
+					 struct file *file);
 static void *afs_proc_cell_volumes_start(struct seq_file *p, loff_t *pos);
-static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v, loff_t *pos);
+static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
+					loff_t *pos);
 static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v);
 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v);
 
@@ -65,10 +68,13 @@
 	.release	= afs_proc_cell_volumes_release,
 };
 
-static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file);
-static int afs_proc_cell_vlservers_release(struct inode *inode, struct file *file);
+static int afs_proc_cell_vlservers_open(struct inode *inode,
+					struct file *file);
+static int afs_proc_cell_vlservers_release(struct inode *inode,
+					   struct file *file);
 static void *afs_proc_cell_vlservers_start(struct seq_file *p, loff_t *pos);
-static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v, loff_t *pos);
+static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
+					  loff_t *pos);
 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v);
 static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v);
 
@@ -87,9 +93,11 @@
 };
 
 static int afs_proc_cell_servers_open(struct inode *inode, struct file *file);
-static int afs_proc_cell_servers_release(struct inode *inode, struct file *file);
+static int afs_proc_cell_servers_release(struct inode *inode,
+					 struct file *file);
 static void *afs_proc_cell_servers_start(struct seq_file *p, loff_t *pos);
-static void *afs_proc_cell_servers_next(struct seq_file *p, void *v, loff_t *pos);
+static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
+					loff_t *pos);
 static void afs_proc_cell_servers_stop(struct seq_file *p, void *v);
 static int afs_proc_cell_servers_show(struct seq_file *m, void *v);
 
@@ -117,12 +125,12 @@
 
 	_enter("");
 
-	proc_afs = proc_mkdir("fs/afs",NULL);
+	proc_afs = proc_mkdir("fs/afs", NULL);
 	if (!proc_afs)
 		goto error;
 	proc_afs->owner = THIS_MODULE;
 
-	p = create_proc_entry("cells",0,proc_afs);
+	p = create_proc_entry("cells", 0, proc_afs);
 	if (!p)
 		goto error_proc;
 	p->proc_fops = &afs_proc_cells_fops;
@@ -131,12 +139,8 @@
 	_leave(" = 0");
 	return 0;
 
-#if 0
- error_cells:
-	remove_proc_entry("cells",proc_afs);
-#endif
  error_proc:
-	remove_proc_entry("fs/afs",NULL);
+	remove_proc_entry("fs/afs", NULL);
  error:
 	_leave(" = -ENOMEM");
 	return -ENOMEM;
@@ -149,9 +153,9 @@
  */
 void afs_proc_cleanup(void)
 {
-	remove_proc_entry("cells",proc_afs);
+	remove_proc_entry("cells", proc_afs);
 
-	remove_proc_entry("fs/afs",NULL);
+	remove_proc_entry("fs/afs", NULL);
 
 } /* end afs_proc_cleanup() */
 
@@ -164,8 +168,8 @@
 	struct seq_file *m;
 	int ret;
 
-	ret = seq_open(file,&afs_proc_cells_ops);
-	if (ret<0)
+	ret = seq_open(file, &afs_proc_cells_ops);
+	if (ret < 0)
 		return ret;
 
 	m = file->private_data;
@@ -176,7 +180,8 @@
 
 /*****************************************************************************/
 /*
- * set up the iterator to start reading from the cells list and return the first item
+ * set up the iterator to start reading from the cells list and return the
+ * first item
  */
 static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
 {
@@ -188,15 +193,15 @@
 
 	/* allow for the header line */
 	if (!pos)
-		return (void *)1;
+		return (void *) 1;
 	pos--;
 
 	/* find the n'th element in the list */
-	list_for_each(_p,&afs_proc_cells)
+	list_for_each(_p, &afs_proc_cells)
 		if (!pos--)
 			break;
 
-	return _p!=&afs_proc_cells ? _p : NULL;
+	return _p != &afs_proc_cells ? _p : NULL;
 } /* end afs_proc_cells_start() */
 
 /*****************************************************************************/
@@ -210,9 +215,9 @@
 	(*pos)++;
 
 	_p = v;
-	_p = v==(void*)1 ? afs_proc_cells.next : _p->next;
+	_p = v == (void *) 1 ? afs_proc_cells.next : _p->next;
 
-	return _p!=&afs_proc_cells ? _p : NULL;
+	return _p != &afs_proc_cells ? _p : NULL;
 } /* end afs_proc_cells_next() */
 
 /*****************************************************************************/
@@ -231,16 +236,16 @@
  */
 static int afs_proc_cells_show(struct seq_file *m, void *v)
 {
-	afs_cell_t *cell = list_entry(v,afs_cell_t,proc_link);
+	struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
 
 	/* display header on line 1 */
-	if (v == (void *)1) {
+	if (v == (void *) 1) {
 		seq_puts(m, "USE NAME\n");
 		return 0;
 	}
 
 	/* display one cell per line on subsequent lines */
-	seq_printf(m,"%3d %s\n",atomic_read(&cell->usage),cell->name);
+	seq_printf(m, "%3d %s\n", atomic_read(&cell->usage), cell->name);
 
 	return 0;
 } /* end afs_proc_cells_show() */
@@ -250,49 +255,59 @@
  * handle writes to /proc/fs/afs/cells
  * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]*
  */
-static ssize_t afs_proc_cells_write(struct file *file, const char *buf, size_t size, loff_t *_pos)
+static ssize_t afs_proc_cells_write(struct file *file, const char *buf,
+				    size_t size, loff_t *_pos)
 {
 	char *kbuf, *name, *args;
 	int ret;
 
 	/* start by dragging the command into memory */
-	if (size<=1 || size>=PAGE_SIZE)
+	if (size <= 1 || size >= PAGE_SIZE)
 		return -EINVAL;
 
-	kbuf = kmalloc(size+1,GFP_KERNEL);
+	kbuf = kmalloc(size + 1, GFP_KERNEL);
 	if (!kbuf)
 		return -ENOMEM;
 
 	ret = -EFAULT;
-	if (copy_from_user(kbuf,buf,size)!=0)
+	if (copy_from_user(kbuf, buf, size) != 0)
 		goto done;
 	kbuf[size] = 0;
 
 	/* trim to first NL */
-	name = memchr(kbuf,'\n',size);
-	if (name) *name = 0;
+	name = memchr(kbuf, '\n', size);
+	if (name)
+		*name = 0;
 
 	/* split into command, name and argslist */
-	name = strchr(kbuf,' ');
-	if (!name) goto inval;
-	do { *name++ = 0; } while(*name==' ');
-	if (!*name) goto inval;
-
-	args = strchr(name,' ');
-	if (!args) goto inval;
-	do { *args++ = 0; } while(*args==' ');
-	if (!*args) goto inval;
+	name = strchr(kbuf, ' ');
+	if (!name)
+		goto inval;
+	do {
+		*name++ = 0;
+	} while(*name == ' ');
+	if (!*name)
+		goto inval;
+
+	args = strchr(name, ' ');
+	if (!args)
+		goto inval;
+	do {
+		*args++ = 0;
+	} while(*args == ' ');
+	if (!*args)
+		goto inval;
 
 	/* determine command to perform */
-	_debug("cmd=%s name=%s args=%s",kbuf,name,args);
+	_debug("cmd=%s name=%s args=%s", kbuf, name, args);
 
-	if (strcmp(kbuf,"add")==0) {
-		afs_cell_t *cell;
-		ret = afs_cell_create(name,args,&cell);
-		if (ret<0)
+	if (strcmp(kbuf, "add") == 0) {
+		struct afs_cell *cell;
+		ret = afs_cell_create(name, args, &cell);
+		if (ret < 0)
 			goto done;
 
-		printk("kAFS: Added new cell '%s'\n",name);
+		printk("kAFS: Added new cell '%s'\n", name);
 	}
 	else {
 		goto inval;
@@ -302,7 +317,7 @@
 
  done:
 	kfree(kbuf);
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
  inval:
@@ -315,31 +330,31 @@
 /*
  * initialise /proc/fs/afs/<cell>/
  */
-int afs_proc_cell_setup(afs_cell_t *cell)
+int afs_proc_cell_setup(struct afs_cell *cell)
 {
 	struct proc_dir_entry *p;
 
-	_enter("%p{%s}",cell,cell->name);
+	_enter("%p{%s}", cell, cell->name);
 
-	cell->proc_dir = proc_mkdir(cell->name,proc_afs);
+	cell->proc_dir = proc_mkdir(cell->name, proc_afs);
 	if (!cell->proc_dir)
 		return -ENOMEM;
 
-	p = create_proc_entry("servers",0,cell->proc_dir);
+	p = create_proc_entry("servers", 0, cell->proc_dir);
 	if (!p)
 		goto error_proc;
 	p->proc_fops = &afs_proc_cell_servers_fops;
 	p->owner = THIS_MODULE;
 	p->data = cell;
 
-	p = create_proc_entry("vlservers",0,cell->proc_dir);
+	p = create_proc_entry("vlservers", 0, cell->proc_dir);
 	if (!p)
 		goto error_servers;
 	p->proc_fops = &afs_proc_cell_vlservers_fops;
 	p->owner = THIS_MODULE;
 	p->data = cell;
 
-	p = create_proc_entry("volumes",0,cell->proc_dir);
+	p = create_proc_entry("volumes", 0, cell->proc_dir);
 	if (!p)
 		goto error_vlservers;
 	p->proc_fops = &afs_proc_cell_volumes_fops;
@@ -350,11 +365,11 @@
 	return 0;
 
  error_vlservers:
-	remove_proc_entry("vlservers",cell->proc_dir);
+	remove_proc_entry("vlservers", cell->proc_dir);
  error_servers:
-	remove_proc_entry("servers",cell->proc_dir);
+	remove_proc_entry("servers", cell->proc_dir);
  error_proc:
-	remove_proc_entry(cell->name,proc_afs);
+	remove_proc_entry(cell->name, proc_afs);
 	_leave(" = -ENOMEM");
 	return -ENOMEM;
 } /* end afs_proc_cell_setup() */
@@ -363,14 +378,14 @@
 /*
  * remove /proc/fs/afs/<cell>/
  */
-void afs_proc_cell_remove(afs_cell_t *cell)
+void afs_proc_cell_remove(struct afs_cell *cell)
 {
 	_enter("");
 
-	remove_proc_entry("volumes",cell->proc_dir);
-	remove_proc_entry("vlservers",cell->proc_dir);
-	remove_proc_entry("servers",cell->proc_dir);
-	remove_proc_entry(cell->name,proc_afs);
+	remove_proc_entry("volumes", cell->proc_dir);
+	remove_proc_entry("vlservers", cell->proc_dir);
+	remove_proc_entry("servers", cell->proc_dir);
+	remove_proc_entry(cell->name, proc_afs);
 
 	_leave("");
 } /* end afs_proc_cell_remove() */
@@ -381,16 +396,16 @@
  */
 static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file)
 {
+	struct afs_cell *cell;
 	struct seq_file *m;
-	afs_cell_t *cell;
 	int ret;
 
-	cell = afs_get_cell_maybe((afs_cell_t**)&PDE(inode)->data);
+	cell = afs_get_cell_maybe((struct afs_cell **) &PDE(inode)->data);
 	if (!cell)
 		return -ENOENT;
 
-	ret = seq_open(file,&afs_proc_cell_volumes_ops);
-	if (ret<0)
+	ret = seq_open(file, &afs_proc_cell_volumes_ops);
+	if (ret < 0)
 		return ret;
 
 	m = file->private_data;
@@ -405,7 +420,7 @@
  */
 static int afs_proc_cell_volumes_release(struct inode *inode, struct file *file)
 {
-	afs_cell_t *cell = PDE(inode)->data;
+	struct afs_cell *cell = PDE(inode)->data;
 	int ret;
 
 	ret = seq_release(inode,file);
@@ -417,49 +432,51 @@
 
 /*****************************************************************************/
 /*
- * set up the iterator to start reading from the cells list and return the first item
+ * set up the iterator to start reading from the cells list and return the
+ * first item
  */
 static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
 {
 	struct list_head *_p;
-	afs_cell_t *cell = m->private;
+	struct afs_cell *cell = m->private;
 	loff_t pos = *_pos;
 
-	_enter("cell=%p pos=%Ld",cell,*_pos);
+	_enter("cell=%p pos=%Ld", cell, *_pos);
 
 	/* lock the list against modification */
 	down_read(&cell->vl_sem);
 
 	/* allow for the header line */
 	if (!pos)
-		return (void *)1;
+		return (void *) 1;
 	pos--;
 
 	/* find the n'th element in the list */
-	list_for_each(_p,&cell->vl_list)
+	list_for_each(_p, &cell->vl_list)
 		if (!pos--)
 			break;
 
-	return _p!=&cell->vl_list ? _p : NULL;
+	return _p != &cell->vl_list ? _p : NULL;
 } /* end afs_proc_cell_volumes_start() */
 
 /*****************************************************************************/
 /*
  * move to next cell in cells list
  */
-static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v, loff_t *_pos)
+static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
+					loff_t *_pos)
 {
 	struct list_head *_p;
-	afs_cell_t *cell = p->private;
+	struct afs_cell *cell = p->private;
 
-	_enter("cell=%p pos=%Ld",cell,*_pos);
+	_enter("cell=%p pos=%Ld", cell, *_pos);
 
 	(*_pos)++;
 
 	_p = v;
-	_p = v==(void*)1 ? cell->vl_list.next : _p->next;
+	_p = v == (void *) 1 ? cell->vl_list.next : _p->next;
 
-	return _p!=&cell->vl_list ? _p : NULL;
+	return _p != &cell->vl_list ? _p : NULL;
 } /* end afs_proc_cell_volumes_next() */
 
 /*****************************************************************************/
@@ -468,7 +485,7 @@
  */
 static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v)
 {
-	afs_cell_t *cell = p->private;
+	struct afs_cell *cell = p->private;
 
 	up_read(&cell->vl_sem);
 
@@ -480,16 +497,17 @@
  */
 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
 {
-	afs_vlocation_t *vlocation = list_entry(v,afs_vlocation_t,link);
+	struct afs_vlocation *vlocation =
+		list_entry(v, struct afs_vlocation, link);
 
 	/* display header on line 1 */
-	if (v == (void *)1) {
+	if (v == (void *) 1) {
 		seq_puts(m, "USE VLID[0]  VLID[1]  VLID[2]  NAME\n");
 		return 0;
 	}
 
 	/* display one cell per line on subsequent lines */
-	seq_printf(m,"%3d %08x %08x %08x %s\n",
+	seq_printf(m, "%3d %08x %08x %08x %s\n",
 		   atomic_read(&vlocation->usage),
 		   vlocation->vldb.vid[0],
 		   vlocation->vldb.vid[1],
@@ -502,15 +520,16 @@
 
 /*****************************************************************************/
 /*
- * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume location server
+ * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
+ * location server
  */
 static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file)
 {
+	struct afs_cell *cell;
 	struct seq_file *m;
-	afs_cell_t *cell;
 	int ret;
 
-	cell = afs_get_cell_maybe((afs_cell_t**)&PDE(inode)->data);
+	cell = afs_get_cell_maybe((struct afs_cell**)&PDE(inode)->data);
 	if (!cell)
 		return -ENOENT;
 
@@ -528,9 +547,10 @@
 /*
  * close the file and release the ref to the cell
  */
-static int afs_proc_cell_vlservers_release(struct inode *inode, struct file *file)
+static int afs_proc_cell_vlservers_release(struct inode *inode,
+					   struct file *file)
 {
-	afs_cell_t *cell = PDE(inode)->data;
+	struct afs_cell *cell = PDE(inode)->data;
 	int ret;
 
 	ret = seq_release(inode,file);
@@ -542,24 +562,25 @@
 
 /*****************************************************************************/
 /*
- * set up the iterator to start reading from the cells list and return the first item
+ * set up the iterator to start reading from the cells list and return the
+ * first item
  */
 static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
 {
-	afs_cell_t *cell = m->private;
+	struct afs_cell *cell = m->private;
 	loff_t pos = *_pos;
 
-	_enter("cell=%p pos=%Ld",cell,*_pos);
+	_enter("cell=%p pos=%Ld", cell, *_pos);
 
 	/* lock the list against modification */
 	down_read(&cell->vl_sem);
 
 	/* allow for the header line */
 	if (!pos)
-		return (void *)1;
+		return (void *) 1;
 	pos--;
 
-	if (pos>=cell->vl_naddrs)
+	if (pos >= cell->vl_naddrs)
 		return NULL;
 
 	return &cell->vl_addrs[pos];
@@ -569,16 +590,17 @@
 /*
  * move to next cell in cells list
  */
-static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v, loff_t *_pos)
+static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
+					  loff_t *_pos)
 {
-	afs_cell_t *cell = p->private;
+	struct afs_cell *cell = p->private;
 	loff_t pos;
 
-	_enter("cell=%p{nad=%u} pos=%Ld",cell,cell->vl_naddrs,*_pos);
+	_enter("cell=%p{nad=%u} pos=%Ld", cell, cell->vl_naddrs, *_pos);
 
 	pos = *_pos;
 	(*_pos)++;
-	if (pos>=cell->vl_naddrs)
+	if (pos >= cell->vl_naddrs)
 		return NULL;
 
 	return &cell->vl_addrs[pos];
@@ -590,7 +612,7 @@
  */
 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v)
 {
-	afs_cell_t *cell = p->private;
+	struct afs_cell *cell = p->private;
 
 	up_read(&cell->vl_sem);
 
@@ -605,33 +627,34 @@
 	struct in_addr *addr = v;
 
 	/* display header on line 1 */
-	if (v == (struct in_addr *)1) {
-		seq_puts(m,"ADDRESS\n");
+	if (v == (struct in_addr *) 1) {
+		seq_puts(m, "ADDRESS\n");
 		return 0;
 	}
 
 	/* display one cell per line on subsequent lines */
-	seq_printf(m,"%u.%u.%u.%u\n",NIPQUAD(addr->s_addr));
+	seq_printf(m, "%u.%u.%u.%u\n", NIPQUAD(addr->s_addr));
 
 	return 0;
 } /* end afs_proc_cell_vlservers_show() */
 
 /*****************************************************************************/
 /*
- * open "/proc/fs/afs/<cell>/servers" which provides a summary of active servers
+ * open "/proc/fs/afs/<cell>/servers" which provides a summary of active
+ * servers
  */
 static int afs_proc_cell_servers_open(struct inode *inode, struct file *file)
 {
+	struct afs_cell *cell;
 	struct seq_file *m;
-	afs_cell_t *cell;
 	int ret;
 
-	cell = afs_get_cell_maybe((afs_cell_t**)&PDE(inode)->data);
+	cell = afs_get_cell_maybe((struct afs_cell **) &PDE(inode)->data);
 	if (!cell)
 		return -ENOENT;
 
-	ret = seq_open(file,&afs_proc_cell_servers_ops);
-	if (ret<0)
+	ret = seq_open(file, &afs_proc_cell_servers_ops);
+	if (ret < 0)
 		return ret;
 
 	m = file->private_data;
@@ -644,12 +667,13 @@
 /*
  * close the file and release the ref to the cell
  */
-static int afs_proc_cell_servers_release(struct inode *inode, struct file *file)
+static int afs_proc_cell_servers_release(struct inode *inode,
+					 struct file *file)
 {
-	afs_cell_t *cell = PDE(inode)->data;
+	struct afs_cell *cell = PDE(inode)->data;
 	int ret;
 
-	ret = seq_release(inode,file);
+	ret = seq_release(inode, file);
 
 	afs_put_cell(cell);
 
@@ -658,49 +682,51 @@
 
 /*****************************************************************************/
 /*
- * set up the iterator to start reading from the cells list and return the first item
+ * set up the iterator to start reading from the cells list and return the
+ * first item
  */
 static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
 {
 	struct list_head *_p;
-	afs_cell_t *cell = m->private;
+	struct afs_cell *cell = m->private;
 	loff_t pos = *_pos;
 
-	_enter("cell=%p pos=%Ld",cell,*_pos);
+	_enter("cell=%p pos=%Ld", cell, *_pos);
 
 	/* lock the list against modification */
 	read_lock(&cell->sv_lock);
 
 	/* allow for the header line */
 	if (!pos)
-		return (void *)1;
+		return (void *) 1;
 	pos--;
 
 	/* find the n'th element in the list */
-	list_for_each(_p,&cell->sv_list)
+	list_for_each(_p, &cell->sv_list)
 		if (!pos--)
 			break;
 
-	return _p!=&cell->sv_list ? _p : NULL;
+	return _p != &cell->sv_list ? _p : NULL;
 } /* end afs_proc_cell_servers_start() */
 
 /*****************************************************************************/
 /*
  * move to next cell in cells list
  */
-static void *afs_proc_cell_servers_next(struct seq_file *p, void *v, loff_t *_pos)
+static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
+					loff_t *_pos)
 {
 	struct list_head *_p;
-	afs_cell_t *cell = p->private;
+	struct afs_cell *cell = p->private;
 
-	_enter("cell=%p pos=%Ld",cell,*_pos);
+	_enter("cell=%p pos=%Ld", cell, *_pos);
 
 	(*_pos)++;
 
 	_p = v;
-	_p = v==(void*)1 ? cell->sv_list.next : _p->next;
+	_p = v == (void *) 1 ? cell->sv_list.next : _p->next;
 
-	return _p!=&cell->sv_list ? _p : NULL;
+	return _p != &cell->sv_list ? _p : NULL;
 } /* end afs_proc_cell_servers_next() */
 
 /*****************************************************************************/
@@ -709,7 +735,7 @@
  */
 static void afs_proc_cell_servers_stop(struct seq_file *p, void *v)
 {
-	afs_cell_t *cell = p->private;
+	struct afs_cell *cell = p->private;
 
 	read_unlock(&cell->sv_lock);
 
@@ -721,18 +747,18 @@
  */
 static int afs_proc_cell_servers_show(struct seq_file *m, void *v)
 {
-	afs_server_t *server = list_entry(v,afs_server_t,link);
+	struct afs_server *server = list_entry(v, struct afs_server, link);
 	char ipaddr[20];
 
 	/* display header on line 1 */
-	if (v == (void *)1) {
+	if (v == (void *) 1) {
 		seq_puts(m, "USE ADDR            STATE\n");
 		return 0;
 	}
 
 	/* display one cell per line on subsequent lines */
-	sprintf(ipaddr,"%u.%u.%u.%u",NIPQUAD(server->addr));
-	seq_printf(m,"%3d %-15.15s %5d\n",
+	sprintf(ipaddr, "%u.%u.%u.%u", NIPQUAD(server->addr));
+	seq_printf(m, "%3d %-15.15s %5d\n",
 		   atomic_read(&server->usage),
 		   ipaddr,
 		   server->fs_state

Index: mntpt.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/mntpt.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -r1.10 -r1.11
--- mntpt.c	15 Aug 2003 13:02:20 -0000	1.10
+++ mntpt.c	10 Sep 2003 13:32:37 -0000	1.11
@@ -67,18 +67,21 @@
  * check a symbolic link to see whether it actually encodes a mountpoint
  * - sets the AFS_VNODE_MOUNTPOINT flag on the vnode appropriately
  */
-int afs_mntpt_check_symlink(afs_vnode_t *vnode)
+int afs_mntpt_check_symlink(struct afs_vnode *vnode)
 {
 	struct page *page;
 	size_t size;
 	char *buf;
 	int ret;
 
-	_enter("{%u,%u}",vnode->fid.vnode,vnode->fid.unique);
+	_enter("{%u,%u}", vnode->fid.vnode, vnode->fid.unique);
 
 	/* read the contents of the symlink into the pagecache */
-	page = read_cache_page(AFS_VNODE_TO_I(vnode)->i_mapping,0,
-			       (filler_t*)AFS_VNODE_TO_I(vnode)->i_mapping->a_ops->readpage,NULL);
+	filler_t *filler =
+		(filler_t *) AFS_VNODE_TO_I(vnode)->i_mapping->a_ops->readpage;
+
+	page = read_cache_page(AFS_VNODE_TO_I(vnode)->i_mapping, 0,
+			       filler, NULL);
 	if (IS_ERR(page)) {
 		ret = PTR_ERR(page);
 		goto out;
@@ -94,11 +97,11 @@
 
 	/* examine the symlink's contents */
 	size = vnode->status.size;
-	_debug("symlink to %*.*s",size,(int)size,buf);
+	_debug("symlink to %*.*s", size, (int) size, buf);
 
-	if (size>2 &&
-	    (buf[0]=='%' || buf[0]=='#') &&
-	    buf[size-1]=='.'
+	if (size > 2 &&
+	    (buf[0] == '%' || buf[0] == '#') &&
+	    buf[size - 1] == '.'
 	    ) {
 		_debug("symlink is a mountpoint");
 		spin_lock(&vnode->lock);
@@ -112,7 +115,7 @@
 	kunmap(page);
 	page_cache_release(page);
  out:
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_mntpt_check_symlink() */
@@ -129,7 +132,8 @@
 	       dir,
 	       dentry,
 	       dentry->d_parent,
-	       dentry->d_parent ? dentry->d_parent->d_name.name : (const unsigned char*)"",
+	       dentry->d_parent ?
+	       dentry->d_parent->d_name.name : (const unsigned char *) "",
 	       dentry->d_name.name);
 
 	return ERR_PTR(-EREMOTE);
@@ -144,7 +148,9 @@
 	kenter("%p,%p{%p{%s},%s}",
 	       inode, file,
 	       file->f_dentry->d_parent,
-	       file->f_dentry->d_parent ? file->f_dentry->d_parent->d_name.name : (const unsigned char*)"",
+	       file->f_dentry->d_parent ?
+	       file->f_dentry->d_parent->d_name.name :
+	       (const unsigned char *) "",
 	       file->f_dentry->d_name.name);
 
 	return -EREMOTE;
@@ -183,10 +189,9 @@
 		goto error;
 
 	/* read the contents of the AFS special symlink */
-	page = read_cache_page(mntpt->d_inode->i_mapping,
-			       0,
-			       (filler_t*)mntpt->d_inode->i_mapping->a_ops->readpage,
-			       NULL);
+	filler_t *filler = mntpt->d_inode->i_mapping->a_ops->readpage;
+
+	page = read_cache_page(mntpt->d_inode->i_mapping, 0, filler, NULL);
 	if (IS_ERR(page)) {
 		ret = PTR_ERR(page);
 		goto error;
@@ -208,26 +213,26 @@
 	memcpy(options, "cell=", 5);
 	strcpy(options + 5, super->volume->cell->name);
 	if (super->volume->type == AFSVL_RWVOL)
-		strcat(options,",rwpath");
+		strcat(options, ",rwpath");
 
 	/* try and do the mount */
 	kdebug("--- attempting mount %s -o %s ---", devname, options);
 	mnt = do_kern_mount("afs", 0, devname, options);
 	kdebug("--- mount result %p ---", mnt);
 
-	free_page((unsigned long)devname);
-	free_page((unsigned long)options);
-	kleave(" = %p",mnt);
+	free_page((unsigned long) devname);
+	free_page((unsigned long) options);
+	kleave(" = %p", mnt);
 	return mnt;
 
  error:
 	if (page)
 		page_cache_release(page);
 	if (devname)
-		free_page((unsigned long)devname);
+		free_page((unsigned long) devname);
 	if (options)
-		free_page((unsigned long)options);
-	kleave(" = %d",ret);
+		free_page((unsigned long) options);
+	kleave(" = %d", ret);
 	return ERR_PTR(ret);
 } /* end afs_mntpt_do_automount() */
 
@@ -252,7 +257,7 @@
 	if (IS_ERR(newmnt))
 		return PTR_ERR(newmnt);
 
-	struct_cpy(&newnd,nd);
+	struct_cpy(&newnd, nd);
 	newnd.dentry = dentry;
 	err = do_add_mount(newmnt, &newnd, 0, &afs_vfsmounts);

Index: main.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/main.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -r1.14 -r1.15
--- main.c	10 Sep 2003 08:23:15 -0000	1.14
+++ main.c	10 Sep 2003 13:32:37 -0000	1.15
@@ -72,7 +72,7 @@
 
 	/* initialise the callback hash table */
 	spin_lock_init(&afs_cb_hash_lock);
-	for (loop=AFS_CB_HASH_COUNT-1; loop>=0; loop--)
+	for (loop = AFS_CB_HASH_COUNT - 1; loop >= 0; loop--)
 		INIT_LIST_HEAD(&afs_cb_hash_tbl[loop]);
 
 	/* register the /proc stuff */
@@ -82,7 +82,8 @@
 
 #ifdef AFS_CACHING_SUPPORT
 	/* we want to be able to cache */
-	ret = cachefs_register_netfs(&afs_cache_netfs,&afs_cache_cell_index_def);
+	ret = cachefs_register_netfs(&afs_cache_netfs,
+				     &afs_cache_cell_index_def);
 	if (ret < 0)
 		goto error;
 #endif
@@ -109,7 +110,7 @@
 		goto error_kafstimod;
 
 	/* create the RxRPC transport */
-	ret = rxrpc_create_transport(7001,&afs_transport);
+	ret = rxrpc_create_transport(7001, &afs_transport);
 	if (ret < 0)
 		goto error_kafsasyncd;
 
@@ -139,7 +140,7 @@
 #endif
 	afs_cell_purge();
 	afs_proc_cleanup();
-	printk(KERN_ERR "kAFS: failed to register: %d\n",ret);
+	printk(KERN_ERR "kAFS: failed to register: %d\n", ret);
 	return ret;
 } /* end afs_init() */
 
@@ -175,19 +176,20 @@
  */
 static int afs_adding_peer(struct rxrpc_peer *peer)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	int ret;
 
-	_debug("kAFS: Adding new peer %08x\n",ntohl(peer->addr.s_addr));
+	_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);
+	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("Server %p{u=%d}\n", server, atomic_read(&server->usage));
 
-	_debug("Cell %p{u=%d}\n",server->cell,atomic_read(&server->cell->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);
@@ -207,14 +209,14 @@
  */
 static void afs_discarding_peer(struct rxrpc_peer *peer)
 {
-	afs_server_t *server;
+	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));
+	       (long) (peer->rtt / 1000),
+	       (long) (peer->rtt % 1000));
 
 	/* uncross-point the structs under a global lock */
 	spin_lock(&afs_server_peer_lock);
@@ -222,9 +224,6 @@
 	if (server) {
 		peer->user = NULL;
 		server->peer = NULL;
-
-		//_debug("Server %p{u=%d}\n",server,atomic_read(&server->usage));
-		//_debug("Cell %p{u=%d}\n",server->cell,atomic_read(&server->cell->usage));
 	}
 	spin_unlock(&afs_server_peer_lock);
 
@@ -252,7 +251,7 @@
                     "  movl    $0xedededed,%%eax     \n"
                     "  rep stosl               \n"
                     :
-                    : "i"(~(THREAD_SIZE-1)), "i"(sizeof(struct thread_info))
+                    : "i"(~(THREAD_SIZE - 1)), "i"(sizeof(struct thread_info))
                     : "eax", "ecx", "edi", "memory", "cc"
                     );
 }
@@ -271,7 +270,7 @@
                     "  movl    $0xdadadada,%%eax     \n"
                     "  rep stosl               \n"
                     :
-                    : "i"(~(THREAD_SIZE-1)), "i"(sizeof(struct thread_info))
+                    : "i"(~(THREAD_SIZE - 1)), "i"(sizeof(struct thread_info))
                     : "eax", "ecx", "edi", "memory", "cc"
                     );
 }

Index: kafstimod.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/kafstimod.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -r1.1.1.1 -r1.2
--- kafstimod.h	19 Jun 2002 13:34:06 -0000	1.1.1.1
+++ kafstimod.h	10 Sep 2003 13:32:37 -0000	1.2
@@ -14,6 +14,8 @@
 
 #include "types.h"
 
+struct afs_timer;
+
 struct afs_timer_ops {
 	/* called when the front of the timer queue has timed out */
 	void (*timed_out)(struct afs_timer *timer);
@@ -30,7 +32,8 @@
 	const struct afs_timer_ops	*ops;		/* timeout expiry function */
 };
 
-static inline void afs_timer_init(afs_timer_t *timer, const struct afs_timer_ops *ops)
+static inline void afs_timer_init(struct afs_timer *timer,
+				  const struct afs_timer_ops *ops)
 {
 	INIT_LIST_HEAD(&timer->link);
 	timer->ops = ops;
@@ -39,7 +42,8 @@
 extern int afs_kafstimod_start(void);
 extern void afs_kafstimod_stop(void);
 
-extern void afs_kafstimod_add_timer(afs_timer_t *timer, unsigned long timeout);
-extern int afs_kafstimod_del_timer(afs_timer_t *timer);
+extern void afs_kafstimod_add_timer(struct afs_timer *timer,
+				    unsigned long timeout);
+extern int afs_kafstimod_del_timer(struct afs_timer *timer);
 
 #endif /* _LINUX_AFS_KAFSTIMOD_H */

Index: kafstimod.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/kafstimod.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- kafstimod.c	10 Sep 2003 08:23:15 -0000	1.9
+++ kafstimod.c	10 Sep 2003 13:32:37 -0000	1.10
@@ -37,8 +37,8 @@
 {
 	int ret;
 
-	ret = kernel_thread(kafstimod,NULL,0);
-	if (ret<0)
+	ret = kernel_thread(kafstimod, NULL, 0);
+	if (ret < 0)
 		return ret;
 
 	wait_for_completion(&kafstimod_alive);
@@ -65,11 +65,11 @@
  */
 static int kafstimod(void *arg)
 {
-	DECLARE_WAITQUEUE(myself,current);
+	struct afs_timer *timer;
 
-	afs_timer_t *timer;
+	DECLARE_WAITQUEUE(myself, current);
 
-	printk("kAFS: Started kafstimod %d\n",current->pid);
+	printk("kAFS: Started kafstimod %d\n", current->pid);
 
 	daemonize("kafstimod");
 
@@ -78,7 +78,7 @@
 	/* loop around looking for things to attend to */
  loop:
 	set_current_state(TASK_INTERRUPTIBLE);
-	add_wait_queue(&kafstimod_sleepq,&myself);
+	add_wait_queue(&kafstimod_sleepq, &myself);
 
 	for (;;) {
 		unsigned long jif;
@@ -86,9 +86,9 @@
 
 		/* deal with the server being asked to die */
 		if (kafstimod_die) {
-			remove_wait_queue(&kafstimod_sleepq,&myself);
+			remove_wait_queue(&kafstimod_sleepq, &myself);
 			_leave("");
-			complete_and_exit(&kafstimod_dead,0);
+			complete_and_exit(&kafstimod_dead, 0);
 		}
 
 		/* discard pending signals */
@@ -100,15 +100,16 @@
 			timeout = MAX_SCHEDULE_TIMEOUT;
 		}
 		else {
-			timer = list_entry(kafstimod_list.next,afs_timer_t,link);
+			timer = list_entry(kafstimod_list.next,
+					   struct afs_timer, link);
 			timeout = timer->timo_jif;
 			jif = jiffies;
 
-			if (time_before_eq((unsigned long)timeout,jif))
+			if (time_before_eq((unsigned long) timeout, jif))
 				goto immediate;
 
 			else {
-				timeout = (long)timeout - (long)jiffies;
+				timeout = (long) timeout - (long) jiffies;
 			}
 		}
 		spin_unlock(&kafstimod_lock);
@@ -119,13 +120,14 @@
 	}
 
 	/* the thing on the front of the queue needs processing
-	 * - we come here with the lock held and timer pointing to the expired entry
+	 * - we come here with the lock held and timer pointing to the expired
+	 *   entry
 	 */
  immediate:
-	remove_wait_queue(&kafstimod_sleepq,&myself);
+	remove_wait_queue(&kafstimod_sleepq, &myself);
 	set_current_state(TASK_RUNNING);
 
-	_debug("@@@ Begin Timeout of %p",timer);
+	_debug("@@@ Begin Timeout of %p", timer);
 
 	/* dequeue the timer */
 	list_del_init(&timer->link);
@@ -143,27 +145,28 @@
 /*
  * (re-)queue a timer
  */
-void afs_kafstimod_add_timer(afs_timer_t *timer, unsigned long timeout)
+void afs_kafstimod_add_timer(struct afs_timer *timer, unsigned long timeout)
 {
+	struct afs_timer *ptimer;
 	struct list_head *_p;
-	afs_timer_t *ptimer;
 
-	_enter("%p,%lu",timer,timeout);
+	_enter("%p,%lu", timer, timeout);
 
 	spin_lock(&kafstimod_lock);
 
 	list_del(&timer->link);
 
-	/* the timer was deferred or reset - put it back in the queue at the right place */
+	/* the timer was deferred or reset - put it back in the queue at the
+	 * right place */
 	timer->timo_jif = jiffies + timeout;
 
-	list_for_each(_p,&kafstimod_list) {
-		ptimer = list_entry(_p,afs_timer_t,link);
-		if (time_before(timer->timo_jif,ptimer->timo_jif))
+	list_for_each(_p, &kafstimod_list) {
+		ptimer = list_entry(_p, struct afs_timer, link);
+		if (time_before(timer->timo_jif, ptimer->timo_jif))
 			break;
 	}
 
-	list_add_tail(&timer->link,_p); /* insert before stopping point */
+	list_add_tail(&timer->link, _p); /* insert before stopping point */
 
 	spin_unlock(&kafstimod_lock);
 
@@ -177,11 +180,11 @@
  * dequeue a timer
  * - returns 0 if the timer was deleted or -ENOENT if it wasn't queued
  */
-int afs_kafstimod_del_timer(afs_timer_t *timer)
+int afs_kafstimod_del_timer(struct afs_timer *timer)
 {
 	int ret = 0;
 
-	_enter("%p",timer);
+	_enter("%p", timer);
 
 	spin_lock(&kafstimod_lock);
 
@@ -194,6 +197,6 @@
 
 	wake_up(&kafstimod_sleepq);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_kafstimod_del_timer() */

Index: kafsasyncd.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/kafsasyncd.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -r1.1.1.1 -r1.2
--- kafsasyncd.h	19 Jun 2002 13:34:06 -0000	1.1.1.1
+++ kafsasyncd.h	10 Sep 2003 13:32:37 -0000	1.2
@@ -14,9 +14,11 @@
 
 #include "types.h"
 
+struct afs_async_op;
+
 struct afs_async_op_ops {
-	void (*attend)(afs_async_op_t *op);
-	void (*discard)(afs_async_op_t *op);
+	void (*attend)(struct afs_async_op *op);
+	void (*discard)(struct afs_async_op *op);
 };
 
 /*****************************************************************************/
@@ -26,13 +28,14 @@
 struct afs_async_op
 {
 	struct list_head		link;
-	afs_server_t			*server;	/* server being contacted */
+	struct afs_server		*server;	/* server being contacted */
 	struct rxrpc_call		*call;		/* RxRPC call performing op */
 	wait_queue_t			waiter;		/* wait queue for kafsasyncd */
 	const struct afs_async_op_ops	*ops;		/* operations */
 };
 
-static inline void afs_async_op_init(afs_async_op_t *op, const struct afs_async_op_ops *ops)
+static inline void afs_async_op_init(struct afs_async_op *op,
+				     const struct afs_async_op_ops *ops)
 {
 	INIT_LIST_HEAD(&op->link);
 	op->call = NULL;
@@ -42,8 +45,8 @@
 extern int afs_kafsasyncd_start(void);
 extern void afs_kafsasyncd_stop(void);
 
-extern void afs_kafsasyncd_begin_op(afs_async_op_t *op);
-extern void afs_kafsasyncd_attend_op(afs_async_op_t *op);
-extern void afs_kafsasyncd_terminate_op(afs_async_op_t *op);
+extern void afs_kafsasyncd_begin_op(struct afs_async_op *op);
+extern void afs_kafsasyncd_attend_op(struct afs_async_op *op);
+extern void afs_kafsasyncd_terminate_op(struct afs_async_op *op);
 
 #endif /* _LINUX_AFS_KAFSASYNCD_H */

Index: kafsasyncd.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/kafsasyncd.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -r1.8 -r1.9
--- kafsasyncd.c	10 Sep 2003 08:23:15 -0000	1.8
+++ kafsasyncd.c	10 Sep 2003 13:32:37 -0000	1.9
@@ -57,8 +57,8 @@
 {
 	int ret;
 
-	ret = kernel_thread(kafsasyncd,NULL,0);
-	if (ret<0)
+	ret = kernel_thread(kafsasyncd, NULL, 0);
+	if (ret < 0)
 		return ret;
 
 	wait_for_completion(&kafsasyncd_alive);
@@ -85,14 +85,14 @@
  */
 static int kafsasyncd(void *arg)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
-	struct list_head *_p;
+	struct afs_async_op *op;
 	int die;
 
+	DECLARE_WAITQUEUE(myself, current);
+
 	kafsasyncd_task = current;
 
-	printk("kAFS: Started kafsasyncd %d\n",current->pid);
+	printk("kAFS: Started kafsasyncd %d\n", current->pid);
 
 	daemonize("kafsasyncd");
 
@@ -101,7 +101,7 @@
 	/* loop around looking for things to attend to */
 	do {
 		set_current_state(TASK_INTERRUPTIBLE);
-		add_wait_queue(&kafsasyncd_sleepq,&myself);
+		add_wait_queue(&kafsasyncd_sleepq, &myself);
 
 		for (;;) {
 			if (!list_empty(&kafsasyncd_async_attnq) ||
@@ -113,7 +113,7 @@
 			set_current_state(TASK_INTERRUPTIBLE);
 		}
 
-		remove_wait_queue(&kafsasyncd_sleepq,&myself);
+		remove_wait_queue(&kafsasyncd_sleepq, &myself);
 		set_current_state(TASK_RUNNING);
 
 		/* discard pending signals */
@@ -121,7 +121,8 @@
 
 		die = kafsasyncd_die;
 
-		/* deal with the next asynchronous operation requiring attention */
+		/* deal with the next asynchronous operation requiring
+		 * attention */
 		if (!list_empty(&kafsasyncd_async_attnq)) {
 			struct afs_async_op *op;
 
@@ -131,14 +132,17 @@
 			spin_lock(&kafsasyncd_async_lock);
 
 			if (!list_empty(&kafsasyncd_async_attnq)) {
-				op = list_entry(kafsasyncd_async_attnq.next,afs_async_op_t,link);
+				op = list_entry(kafsasyncd_async_attnq.next,
+						struct afs_async_op, link);
 				list_del(&op->link);
-				list_add_tail(&op->link,&kafsasyncd_async_busyq);
+				list_add_tail(&op->link,
+					      &kafsasyncd_async_busyq);
 			}
 
 			spin_unlock(&kafsasyncd_async_lock);
 
-			_debug("@@@ Operation %p {%p}\n",op,op?op->ops:NULL);
+			_debug("@@@ Operation %p {%p}\n",
+			       op, op ? op->ops : NULL);
 
 			if (op)
 				op->ops->attend(op);
@@ -148,30 +152,30 @@
 
 	} while(!die);
 
-	/* need to kill all outstanding asynchronous operations before exiting */
+	/* need to kill all outstanding asynchronous operations before
+	 * exiting */
 	kafsasyncd_task = NULL;
 	spin_lock(&kafsasyncd_async_lock);
 
 	/* fold the busy and attention queues together */
-	list_splice_init(&kafsasyncd_async_busyq,&kafsasyncd_async_attnq);
+	list_splice_init(&kafsasyncd_async_busyq,
+			 &kafsasyncd_async_attnq);
 
 	/* dequeue kafsasyncd from all their wait queues */
-	list_for_each(_p,&kafsasyncd_async_attnq) {
-		afs_async_op_t *op = list_entry(_p,afs_async_op_t,link);
-
+	list_for_each_entry(op, &kafsasyncd_async_attnq, link) {
 		op->call->app_attn_func = kafsasyncd_null_call_attn_func;
 		op->call->app_error_func = kafsasyncd_null_call_error_func;
-		remove_wait_queue(&op->call->waitq,&op->waiter);
+		remove_wait_queue(&op->call->waitq, &op->waiter);
 	}
 
 	spin_unlock(&kafsasyncd_async_lock);
 
 	/* abort all the operations */
 	while (!list_empty(&kafsasyncd_async_attnq)) {
-		afs_async_op_t *op = list_entry(_p,afs_async_op_t,link);
+		op = list_entry(kafsasyncd_async_attnq.next, struct afs_async_op, link);
 		list_del_init(&op->link);
 
-		rxrpc_call_abort(op->call,-EIO);
+		rxrpc_call_abort(op->call, -EIO);
 		rxrpc_put_call(op->call);
 		op->call = NULL;
 
@@ -180,7 +184,7 @@
 
 	/* and that's all */
 	_leave("");
-	complete_and_exit(&kafsasyncd_dead,0);
+	complete_and_exit(&kafsasyncd_dead, 0);
 
 } /* end kafsasyncd() */
 
@@ -189,17 +193,17 @@
  * begin an operation
  * - place operation on busy queue
  */
-void afs_kafsasyncd_begin_op(afs_async_op_t *op)
+void afs_kafsasyncd_begin_op(struct afs_async_op *op)
 {
 	_enter("");
 
 	spin_lock(&kafsasyncd_async_lock);
 
-	init_waitqueue_entry(&op->waiter,kafsasyncd_task);
-	add_wait_queue(&op->call->waitq,&op->waiter);
+	init_waitqueue_entry(&op->waiter, kafsasyncd_task);
+	add_wait_queue(&op->call->waitq, &op->waiter);
 
 	list_del(&op->link);
-	list_add_tail(&op->link,&kafsasyncd_async_busyq);
+	list_add_tail(&op->link, &kafsasyncd_async_busyq);
 
 	spin_unlock(&kafsasyncd_async_lock);
 
@@ -211,14 +215,14 @@
  * request attention for an operation
  * - move to attention queue
  */
-void afs_kafsasyncd_attend_op(afs_async_op_t *op)
+void afs_kafsasyncd_attend_op(struct afs_async_op *op)
 {
 	_enter("");
 
 	spin_lock(&kafsasyncd_async_lock);
 
 	list_del(&op->link);
-	list_add_tail(&op->link,&kafsasyncd_async_attnq);
+	list_add_tail(&op->link, &kafsasyncd_async_attnq);
 
 	spin_unlock(&kafsasyncd_async_lock);
 
@@ -232,7 +236,7 @@
  * terminate an operation
  * - remove from either queue
  */
-void afs_kafsasyncd_terminate_op(afs_async_op_t *op)
+void afs_kafsasyncd_terminate_op(struct afs_async_op *op)
 {
 	_enter("");
 
@@ -240,7 +244,7 @@
 
 	if (!list_empty(&op->link)) {
 		list_del_init(&op->link);
-		remove_wait_queue(&op->call->waitq,&op->waiter);
+		remove_wait_queue(&op->call->waitq, &op->waiter);
 	}
 
 	spin_unlock(&kafsasyncd_async_lock);

Index: internal.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/internal.h,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -r1.19 -r1.20
--- internal.h	10 Sep 2003 08:23:15 -0000	1.19
+++ internal.h	10 Sep 2003 13:32:37 -0000	1.20
@@ -46,7 +46,7 @@
 		siginfo_t sinfo;
 
 		spin_lock_irq(&current->sighand->siglock);
-		dequeue_signal(current,&current->blocked,&sinfo);
+		dequeue_signal(current,&current->blocked, &sinfo);
 		spin_unlock_irq(&current->sighand->siglock);
 	}
 }
@@ -74,14 +74,17 @@
 extern struct file_operations afs_file_file_operations;
 
 #ifdef AFS_CACHING_SUPPORT
-extern int afs_cache_get_page_cookie(struct page *page, struct cachefs_page **_page_cookie);
+extern int afs_cache_get_page_cookie(struct page *page,
+				     struct cachefs_page **_page_cookie);
 #endif
 
 /*
  * inode.c
  */
-extern int afs_iget(struct super_block *sb, afs_fid_t *fid, struct inode **_inode);
-extern int afs_inode_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat);
+extern int afs_iget(struct super_block *sb, struct afs_fid *fid,
+		    struct inode **_inode);
+extern int afs_inode_getattr(struct vfsmount *mnt, struct dentry *dentry,
+			     struct kstat *stat);
 extern void afs_clear_inode(struct inode *inode);
 
 /*
@@ -110,7 +113,7 @@
 extern unsigned long afs_mntpt_expiry_timeout;
 #endif
 
-extern int afs_mntpt_check_symlink(afs_vnode_t *vnode);
+extern int afs_mntpt_check_symlink(struct afs_vnode *vnode);
 
 /*
  * super.c
@@ -118,13 +121,14 @@
 extern int afs_fs_init(void);
 extern void afs_fs_exit(void);
 
-#define AFS_CB_HASH_COUNT (PAGE_SIZE/sizeof(struct list_head))
+#define AFS_CB_HASH_COUNT (PAGE_SIZE / sizeof(struct list_head))
 
 extern struct list_head afs_cb_hash_tbl[];
 extern spinlock_t afs_cb_hash_lock;
 
 #define afs_cb_hash(SRV,FID) \
-	afs_cb_hash_tbl[((unsigned long)(SRV) + (FID)->vid + (FID)->vnode + (FID)->unique) % \
+	afs_cb_hash_tbl[((unsigned long)(SRV) + \
+			(FID)->vid + (FID)->vnode + (FID)->unique) % \
 			AFS_CB_HASH_COUNT]
 
 /*
@@ -132,7 +136,7 @@
  */
 extern int afs_proc_init(void);
 extern void afs_proc_cleanup(void);
-extern int afs_proc_cell_setup(afs_cell_t *cell);
-extern void afs_proc_cell_remove(afs_cell_t *cell);
+extern int afs_proc_cell_setup(struct afs_cell *cell);
+extern void afs_proc_cell_remove(struct afs_cell *cell);
 
 #endif /* AFS_INTERNAL_H */

Index: inode.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/inode.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -r1.14 -r1.15
--- inode.c	10 Sep 2003 08:23:15 -0000	1.14
+++ inode.c	10 Sep 2003 13:32:37 -0000	1.15
@@ -26,15 +26,15 @@
 #include "internal.h"
 
 struct afs_iget_data {
-	afs_fid_t		fid;
-	afs_volume_t		*volume;	/* volume on which resides */
+	struct afs_fid		fid;
+	struct afs_volume	*volume;	/* volume on which resides */
 };
 
 /*****************************************************************************/
 /*
  * map the AFS file status to the inode member variables
  */
-static int afs_inode_map_status(afs_vnode_t *vnode)
+static int afs_inode_map_status(struct afs_vnode *vnode)
 {
 	struct inode *inode = AFS_VNODE_TO_I(vnode);
 
@@ -97,7 +97,7 @@
  */
 int afs_inode_fetch_status(struct inode *inode)
 {
-	afs_vnode_t *vnode;
+	struct afs_vnode *vnode;
 	int ret;
 
 	vnode = AFS_FS_I(inode);
@@ -130,7 +130,7 @@
 static int afs_iget5_set(struct inode *inode, void *opaque)
 {
 	struct afs_iget_data *data = opaque;
-	afs_vnode_t *vnode = AFS_FS_I(inode);
+	struct afs_vnode *vnode = AFS_FS_I(inode);
 
 	inode->i_ino = data->fid.vnode;
 	inode->i_version = data->fid.unique;
@@ -144,7 +144,7 @@
 /*
  * inode retrieval
  */
-inline int afs_iget(struct super_block *sb, afs_fid_t *fid,
+inline int afs_iget(struct super_block *sb, struct afs_fid *fid,
 		    struct inode **_inode)
 {
 	struct afs_iget_data data = { fid: *fid };
@@ -222,8 +222,8 @@
 int afs_inode_getattr(struct vfsmount *mnt, struct dentry *dentry,
 		      struct kstat *stat)
 {
+	struct afs_vnode *vnode;
 	struct inode *inode;
-	afs_vnode_t *vnode;
 	int ret;
 
 	inode = dentry->d_inode;
@@ -262,7 +262,7 @@
  */
 void afs_clear_inode(struct inode *inode)
 {
-	afs_vnode_t *vnode;
+	struct afs_vnode *vnode;
 
 	vnode = AFS_FS_I(inode);

Index: fsclient.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/fsclient.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -r1.1.1.1 -r1.2
--- fsclient.h	19 Jun 2002 13:34:06 -0000	1.1.1.1
+++ fsclient.h	10 Sep 2003 13:32:37 -0000	1.2
@@ -14,38 +14,39 @@
 
 #include "server.h"
 
-extern int afs_rxfs_get_volume_info(afs_server_t *server,
+extern int afs_rxfs_get_volume_info(struct afs_server *server,
 				    const char *name,
-				    afs_volume_info_t *vinfo);
+				    struct afs_volume_info *vinfo);
 
-extern int afs_rxfs_fetch_file_status(afs_server_t *server,
-				      afs_vnode_t *vnode,
-				      afs_volsync_t *volsync);
+extern int afs_rxfs_fetch_file_status(struct afs_server *server,
+				      struct afs_vnode *vnode,
+				      struct afs_volsync *volsync);
 
 struct afs_rxfs_fetch_descriptor {
-	afs_fid_t	fid;		/* file ID to fetch */
+	struct afs_fid	fid;		/* file ID to fetch */
 	size_t		size;		/* total number of bytes to fetch */
 	off_t		offset;		/* offset in file to start from */
 	void		*buffer;	/* read buffer */
 	size_t		actual;		/* actual size sent back by server */
 };
 
-extern int afs_rxfs_fetch_file_data(afs_server_t *server,
-				    afs_vnode_t *vnode,
+extern int afs_rxfs_fetch_file_data(struct afs_server *server,
+				    struct afs_vnode *vnode,
 				    struct afs_rxfs_fetch_descriptor *desc,
-				    afs_volsync_t *volsync);
+				    struct afs_volsync *volsync);
 
-extern int afs_rxfs_give_up_callback(afs_server_t *server, afs_vnode_t *vnode);
+extern int afs_rxfs_give_up_callback(struct afs_server *server,
+				     struct afs_vnode *vnode);
 
 /* this doesn't appear to work in OpenAFS server */
-extern int afs_rxfs_lookup(afs_server_t *server,
-			   afs_vnode_t *dir,
+extern int afs_rxfs_lookup(struct afs_server *server,
+			   struct afs_vnode *dir,
 			   const char *filename,
-			   afs_vnode_t *vnode,
-			   afs_volsync_t *volsync);
+			   struct afs_vnode *vnode,
+			   struct afs_volsync *volsync);
 
 /* this is apparently mis-implemented in OpenAFS server */
-extern int afs_rxfs_get_root_volume(afs_server_t *server,
+extern int afs_rxfs_get_root_volume(struct afs_server *server,
 				    char *buf,
 				    size_t *buflen);

Index: fsclient.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/fsclient.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- fsclient.c	16 Oct 2002 11:59:45 -0000	1.3
+++ fsclient.c	10 Sep 2003 13:32:37 -0000	1.4
@@ -24,7 +24,7 @@
 
 #define FSFETCHSTATUS		132	/* AFS Fetch file status */
 #define FSFETCHDATA		130	/* AFS Fetch file data */
-#define FSGIVEUPCALLBACKS	147	/* AFS Discard server callback promises */
+#define FSGIVEUPCALLBACKS	147	/* AFS Discard callback promises */
 #define FSGETVOLUMEINFO		148	/* AFS Get root volume information */
 #define FSGETROOTVOLUME		151	/* AFS Get root volume name */
 #define FSLOOKUP		161	/* AFS lookup file in directory */
@@ -54,10 +54,9 @@
  * - this operation doesn't seem to work correctly in OpenAFS server 1.2.2
  */
 #if 0
-int afs_rxfs_get_root_volume(afs_server_t *server, char *buf, size_t *buflen)
+int afs_rxfs_get_root_volume(struct afs_server *server,
+			     char *buf, size_t *buflen)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
 	struct rxrpc_connection *conn;
 	struct rxrpc_call *call;
 	struct iovec piov[2];
@@ -65,23 +64,25 @@
 	int ret;
 	u32 param[1];
 
-	kenter("%p,%p,%u",server,buf,*buflen);
+	DECLARE_WAITQUEUE(myself, current);
+
+	kenter("%p,%p,%u",server, buf, *buflen);
 
 	/* get hold of the fileserver connection */
-	ret = afs_server_get_fsconn(server,&conn);
-	if (ret<0)
+	ret = afs_server_get_fsconn(server, &conn);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(conn,NULL,NULL,afs_rxfs_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = FSGETROOTVOLUME;
 
 	/* we want to get event notifications from the call */
-	add_wait_queue(&call->waitq,&myself);
+	add_wait_queue(&call->waitq, &myself);
 
 	/* marshall the parameters */
 	param[0] = htonl(FSGETROOTVOLUME);
@@ -90,14 +91,15 @@
 	piov[0].iov_base = param;
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,1,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
 	for (;;) {
 		set_current_state(TASK_INTERRUPTIBLE);
-		if (call->app_call_state!=RXRPC_CSTATE_CLNT_RCV_REPLY ||
+		if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
 		    signal_pending(current))
 			break;
 		schedule();
@@ -111,41 +113,41 @@
 	switch (call->app_call_state) {
 	case RXRPC_CSTATE_ERROR:
 		ret = call->app_errno;
-		kdebug("Got Error: %d",ret);
+		kdebug("Got Error: %d", ret);
 		goto out_unwait;
 
 	case RXRPC_CSTATE_CLNT_GOT_REPLY:
 		/* read the reply */
-		kdebug("Got Reply: qty=%d",call->app_ready_qty);
+		kdebug("Got Reply: qty=%d", call->app_ready_qty);
 
 		ret = -EBADMSG;
 		if (call->app_ready_qty <= 4)
 			goto abort;
 
-		ret = rxrpc_call_read_data(call,NULL,call->app_ready_qty,0);
-		if (ret<0)
+		ret = rxrpc_call_read_data(call, NULL, call->app_ready_qty, 0);
+		if (ret < 0)
 			goto abort;
 
 #if 0
 		/* unmarshall the reply */
 		bp = buffer;
-		for (loop=0; loop<65; loop++)
+		for (loop = 0; loop < 65; loop++)
 			entry->name[loop] = ntohl(*bp++);
 		entry->name[64] = 0;
 
 		entry->type = ntohl(*bp++);
 		entry->num_servers = ntohl(*bp++);
 
-		for (loop=0; loop<8; loop++)
+		for (loop = 0; loop < 8; loop++)
 			entry->servers[loop].addr.s_addr = *bp++;
 
-		for (loop=0; loop<8; loop++)
+		for (loop = 0; loop < 8; loop++)
 			entry->servers[loop].partition = ntohl(*bp++);
 
-		for (loop=0; loop<8; loop++)
+		for (loop = 0; loop < 8; loop++)
 			entry->servers[loop].flags = ntohl(*bp++);
 
-		for (loop=0; loop<3; loop++)
+		for (loop = 0; loop < 3; loop++)
 			entry->volume_ids[loop] = ntohl(*bp++);
 
 		entry->clone_id = ntohl(*bp++);
@@ -162,14 +164,14 @@
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
  out_unwait:
 	set_current_state(TASK_RUNNING);
-	remove_wait_queue(&call->waitq,&myself);
+	remove_wait_queue(&call->waitq, &myself);
 	rxrpc_put_call(call);
  out_put_conn:
-	afs_server_release_fsconn(server,conn);
+	afs_server_release_fsconn(server, conn);
  out:
 	kleave("");
 	return ret;
@@ -181,12 +183,10 @@
  * get information about a volume
  */
 #if 0
-int afs_rxfs_get_volume_info(afs_server_t *server,
+int afs_rxfs_get_volume_info(struct afs_server *server,
 			     const char *name,
-			     afs_volume_info_t *vinfo)
+			     struct afs_volume_info *vinfo)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
 	struct rxrpc_connection *conn;
 	struct rxrpc_call *call;
 	struct iovec piov[3];
@@ -194,27 +194,29 @@
 	int ret;
 	u32 param[2], *bp, zero;
 
-	_enter("%p,%s,%p",server,name,vinfo);
+	DECLARE_WAITQUEUE(myself, current);
+
+	_enter("%p,%s,%p", server, name, vinfo);
 
 	/* get hold of the fileserver connection */
-	ret = afs_server_get_fsconn(server,&conn);
-	if (ret<0)
+	ret = afs_server_get_fsconn(server, &conn);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(conn,NULL,NULL,afs_rxfs_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = FSGETVOLUMEINFO;
 
 	/* we want to get event notifications from the call */
-	add_wait_queue(&call->waitq,&myself);
+	add_wait_queue(&call->waitq, &myself);
 
 	/* marshall the parameters */
 	piov[1].iov_len = strlen(name);
-	piov[1].iov_base = (char*)name;
+	piov[1].iov_base = (char *) name;
 
 	zero = 0;
 	piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
@@ -227,16 +229,19 @@
 	piov[0].iov_base = param;
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,3,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
-	bp = rxrpc_call_alloc_scratch(call,64);
+	bp = rxrpc_call_alloc_scratch(call, 64);
 
-	ret = rxrpc_call_read_data(call,bp,64,RXRPC_CALL_READ_BLOCK|RXRPC_CALL_READ_ALL);
-	if (ret<0) {
-		if (ret==-ECONNABORTED) {
+	ret = rxrpc_call_read_data(call, bp, 64,
+				   RXRPC_CALL_READ_BLOCK |
+				   RXRPC_CALL_READ_ALL);
+	if (ret < 0) {
+		if (ret == -ECONNABORTED) {
 			ret = call->app_errno;
 			goto out_unwait;
 		}
@@ -264,7 +269,7 @@
 	vinfo->servers[7].addr.s_addr = *bp++;
 
 	ret = -EBADMSG;
-	if (vinfo->nservers>8)
+	if (vinfo->nservers > 8)
 		goto abort;
 
 	/* success */
@@ -272,17 +277,17 @@
 
  out_unwait:
 	set_current_state(TASK_RUNNING);
-	remove_wait_queue(&call->waitq,&myself);
+	remove_wait_queue(&call->waitq, &myself);
 	rxrpc_put_call(call);
  out_put_conn:
-	afs_server_release_fsconn(server,conn);
+	afs_server_release_fsconn(server, conn);
  out:
 	_leave("");
 	return ret;
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 	goto out_unwait;
 
@@ -293,12 +298,10 @@
 /*
  * fetch the status information for a file
  */
-int afs_rxfs_fetch_file_status(afs_server_t *server,
-			       afs_vnode_t *vnode,
-			       afs_volsync_t *volsync)
+int afs_rxfs_fetch_file_status(struct afs_server *server,
+			       struct afs_vnode *vnode,
+			       struct afs_volsync *volsync)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
 	struct afs_server_callslot callslot;
 	struct rxrpc_call *call;
 	struct iovec piov[1];
@@ -306,26 +309,30 @@
 	int ret;
 	u32 *bp;
 
-	_enter("%p,{%u,%u,%u}",server,vnode->fid.vid,vnode->fid.vnode,vnode->fid.unique);
+	DECLARE_WAITQUEUE(myself, current);
+
+	_enter("%p,{%u,%u,%u}",
+	       server, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
 
 	/* get hold of the fileserver connection */
-	ret = afs_server_request_callslot(server,&callslot);
-	if (ret<0)
+	ret = afs_server_request_callslot(server, &callslot);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(callslot.conn,NULL,NULL,afs_rxfs_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap,
+				&call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = FSFETCHSTATUS;
 
 	/* we want to get event notifications from the call */
-	add_wait_queue(&call->waitq,&myself);
+	add_wait_queue(&call->waitq, &myself);
 
 	/* marshall the parameters */
-	bp = rxrpc_call_alloc_scratch(call,16);
+	bp = rxrpc_call_alloc_scratch(call, 16);
 	bp[0] = htonl(FSFETCHSTATUS);
 	bp[1] = htonl(vnode->fid.vid);
 	bp[2] = htonl(vnode->fid.vnode);
@@ -335,16 +342,19 @@
 	piov[0].iov_base = bp;
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,1,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
-	bp = rxrpc_call_alloc_scratch(call,120);
+	bp = rxrpc_call_alloc_scratch(call, 120);
 
-	ret = rxrpc_call_read_data(call,bp,120,RXRPC_CALL_READ_BLOCK|RXRPC_CALL_READ_ALL);
-	if (ret<0) {
-		if (ret==-ECONNABORTED) {
+	ret = rxrpc_call_read_data(call, bp, 120,
+				   RXRPC_CALL_READ_BLOCK |
+				   RXRPC_CALL_READ_ALL);
+	if (ret < 0) {
+		if (ret == -ECONNABORTED) {
 			ret = call->app_errno;
 			goto out_unwait;
 		}
@@ -370,7 +380,7 @@
 	vnode->status.mtime_server	= ntohl(*bp++);
 	bp++; /* group */
 	bp++; /* sync counter */
-	vnode->status.version		|= ((unsigned long long) ntohl(*bp++)) << 32;
+	vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
 	bp++; /* spare2 */
 	bp++; /* spare3 */
 	bp++; /* spare4 */
@@ -393,17 +403,17 @@
 
  out_unwait:
 	set_current_state(TASK_RUNNING);
-	remove_wait_queue(&call->waitq,&myself);
+	remove_wait_queue(&call->waitq, &myself);
 	rxrpc_put_call(call);
  out_put_conn:
-	afs_server_release_callslot(server,&callslot);
+	afs_server_release_callslot(server, &callslot);
  out:
 	_leave("");
 	return ret;
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 	goto out_unwait;
 } /* end afs_rxfs_fetch_file_status() */
@@ -412,13 +422,11 @@
 /*
  * fetch the contents of a file or directory
  */
-int afs_rxfs_fetch_file_data(afs_server_t *server,
-			     afs_vnode_t *vnode,
+int afs_rxfs_fetch_file_data(struct afs_server *server,
+			     struct afs_vnode *vnode,
 			     struct afs_rxfs_fetch_descriptor *desc,
-			     afs_volsync_t *volsync)
+			     struct afs_volsync *volsync)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
 	struct afs_server_callslot callslot;
 	struct rxrpc_call *call;
 	struct iovec piov[1];
@@ -426,6 +434,8 @@
 	int ret;
 	u32 *bp;
 
+	DECLARE_WAITQUEUE(myself, current);
+
 	_enter("%p,{fid={%u,%u,%u},sz=%Zu,of=%lu}",
 	       server,
 	       desc->fid.vid,
@@ -435,23 +445,23 @@
 	       desc->offset);
 
 	/* get hold of the fileserver connection */
-	ret = afs_server_request_callslot(server,&callslot);
-	if (ret<0)
+	ret = afs_server_request_callslot(server, &callslot);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(callslot.conn,NULL,NULL,afs_rxfs_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap, &call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = FSFETCHDATA;
 
 	/* we want to get event notifications from the call */
-	add_wait_queue(&call->waitq,&myself);
+	add_wait_queue(&call->waitq, &myself);
 
 	/* marshall the parameters */
-	bp = rxrpc_call_alloc_scratch(call,24);
+	bp = rxrpc_call_alloc_scratch(call, 24);
 	bp[0] = htonl(FSFETCHDATA);
 	bp[1] = htonl(desc->fid.vid);
 	bp[2] = htonl(desc->fid.vnode);
@@ -463,17 +473,18 @@
 	piov[0].iov_base = bp;
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,1,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the data count to arrive */
-	ret = rxrpc_call_read_data(call,bp,4,RXRPC_CALL_READ_BLOCK);
-	if (ret<0)
+	ret = rxrpc_call_read_data(call, bp, 4, RXRPC_CALL_READ_BLOCK);
+	if (ret < 0)
 		goto read_failed;
 
 	desc->actual = ntohl(bp[0]);
-	if (desc->actual!=desc->size) {
+	if (desc->actual != desc->size) {
 		ret = -EBADMSG;
 		goto abort;
 	}
@@ -481,16 +492,19 @@
 	/* call the app to read the actual data */
 	rxrpc_call_reset_scratch(call);
 
-	ret = rxrpc_call_read_data(call,desc->buffer,desc->actual,RXRPC_CALL_READ_BLOCK);
-	if (ret<0)
+	ret = rxrpc_call_read_data(call, desc->buffer, desc->actual,
+				   RXRPC_CALL_READ_BLOCK);
+	if (ret < 0)
 		goto read_failed;
 
 	/* wait for the rest of the reply to completely arrive */
 	rxrpc_call_reset_scratch(call);
-	bp = rxrpc_call_alloc_scratch(call,120);
+	bp = rxrpc_call_alloc_scratch(call, 120);
 
-	ret = rxrpc_call_read_data(call,bp,120,RXRPC_CALL_READ_BLOCK|RXRPC_CALL_READ_ALL);
-	if (ret<0)
+	ret = rxrpc_call_read_data(call, bp, 120,
+				   RXRPC_CALL_READ_BLOCK |
+				   RXRPC_CALL_READ_ALL);
+	if (ret < 0)
 		goto read_failed;
 
 	/* unmarshall the reply */
@@ -512,7 +526,7 @@
 	vnode->status.mtime_server	= ntohl(*bp++);
 	bp++; /* group */
 	bp++; /* sync counter */
-	vnode->status.version		|= ((unsigned long long) ntohl(*bp++)) << 32;
+	vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
 	bp++; /* spare2 */
 	bp++; /* spare3 */
 	bp++; /* spare4 */
@@ -538,20 +552,20 @@
 	remove_wait_queue(&call->waitq,&myself);
 	rxrpc_put_call(call);
  out_put_conn:
-	afs_server_release_callslot(server,&callslot);
+	afs_server_release_callslot(server, &callslot);
  out:
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
  read_failed:
-	if (ret==-ECONNABORTED) {
+	if (ret == -ECONNABORTED) {
 		ret = call->app_errno;
 		goto out_unwait;
 	}
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 	goto out_unwait;
 
@@ -561,10 +575,9 @@
 /*
  * ask the AFS fileserver to discard a callback request on a file
  */
-int afs_rxfs_give_up_callback(afs_server_t *server, afs_vnode_t *vnode)
+int afs_rxfs_give_up_callback(struct afs_server *server,
+			      struct afs_vnode *vnode)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
 	struct afs_server_callslot callslot;
 	struct rxrpc_call *call;
 	struct iovec piov[1];
@@ -572,28 +585,31 @@
 	int ret;
 	u32 *bp;
 
-	_enter("%p,{%u,%u,%u}",server,vnode->fid.vid,vnode->fid.vnode,vnode->fid.unique);
+	DECLARE_WAITQUEUE(myself, current);
+
+	_enter("%p,{%u,%u,%u}",
+	       server, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
 
 	/* get hold of the fileserver connection */
-	ret = afs_server_request_callslot(server,&callslot);
-	if (ret<0)
+	ret = afs_server_request_callslot(server, &callslot);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(callslot.conn,NULL,NULL,afs_rxfs_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap, &call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = FSGIVEUPCALLBACKS;
 
 	/* we want to get event notifications from the call */
-	add_wait_queue(&call->waitq,&myself);
+	add_wait_queue(&call->waitq, &myself);
 
 	/* marshall the parameters */
-	bp = rxrpc_call_alloc_scratch(call,(1+4+4)*4);
+	bp = rxrpc_call_alloc_scratch(call, (1 + 4 + 4) * 4);
 
-	piov[0].iov_len = (1+4+4)*4;
+	piov[0].iov_len = (1 + 4 + 4) * 4;
 	piov[0].iov_base = bp;
 
 	*bp++ = htonl(FSGIVEUPCALLBACKS);
@@ -607,14 +623,15 @@
 	*bp++ = htonl(vnode->cb_type);
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,1,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
 	for (;;) {
 		set_current_state(TASK_INTERRUPTIBLE);
-		if (call->app_call_state!=RXRPC_CSTATE_CLNT_RCV_REPLY ||
+		if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
 		    signal_pending(current))
 			break;
 		schedule();
@@ -640,17 +657,17 @@
 
  out_unwait:
 	set_current_state(TASK_RUNNING);
-	remove_wait_queue(&call->waitq,&myself);
+	remove_wait_queue(&call->waitq, &myself);
 	rxrpc_put_call(call);
  out_put_conn:
-	afs_server_release_callslot(server,&callslot);
+	afs_server_release_callslot(server, &callslot);
  out:
 	_leave("");
 	return ret;
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 	goto out_unwait;
 } /* end afs_rxfs_give_up_callback() */
@@ -661,14 +678,12 @@
  * - this operation doesn't seem to work correctly in OpenAFS server 1.2.2
  */
 #if 0
-int afs_rxfs_lookup(afs_server_t *server,
-		    afs_vnode_t *dir,
+int afs_rxfs_lookup(struct afs_server *server,
+		    struct afs_vnode *dir,
 		    const char *filename,
-		    afs_vnode_t *vnode,
-		    afs_volsync_t *volsync)
+		    struct afs_vnode *vnode,
+		    struct afs_volsync *volsync)
 {
-	DECLARE_WAITQUEUE(myself,current);
-
 	struct rxrpc_connection *conn;
 	struct rxrpc_call *call;
 	struct iovec piov[3];
@@ -676,17 +691,20 @@
 	int ret;
 	u32 *bp, zero;
 
-	kenter("%p,{%u,%u,%u},%s",server,fid->vid,fid->vnode,fid->unique,filename);
+	DECLARE_WAITQUEUE(myself, current);
+
+	kenter("%p,{%u,%u,%u},%s",
+	       server, fid->vid, fid->vnode, fid->unique, filename);
 
 	/* get hold of the fileserver connection */
-	ret = afs_server_get_fsconn(server,&conn);
-	if (ret<0)
+	ret = afs_server_get_fsconn(server, &conn);
+	if (ret < 0)
 		goto out;
 
 	/* create a call through that connection */
-	ret = rxrpc_create_call(conn,NULL,NULL,afs_rxfs_aemap,&call);
-	if (ret<0) {
-		printk("kAFS: Unable to create call: %d\n",ret);
+	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
+	if (ret < 0) {
+		printk("kAFS: Unable to create call: %d\n", ret);
 		goto out_put_conn;
 	}
 	call->app_opcode = FSLOOKUP;
@@ -695,14 +713,14 @@
 	add_wait_queue(&call->waitq,&myself);
 
 	/* marshall the parameters */
-	bp = rxrpc_call_alloc_scratch(call,20);
+	bp = rxrpc_call_alloc_scratch(call, 20);
 
 	zero = 0;
 
 	piov[0].iov_len = 20;
 	piov[0].iov_base = bp;
 	piov[1].iov_len = strlen(filename);
-	piov[1].iov_base = (char*) filename;
+	piov[1].iov_base = (char *) filename;
 	piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
 	piov[2].iov_base = &zero;
 
@@ -713,16 +731,19 @@
 	*bp++ = htonl(piov[1].iov_len);
 
 	/* send the parameters to the server */
-	ret = rxrpc_call_write_data(call,3,piov,RXRPC_LAST_PACKET,GFP_NOFS,0,&sent);
-	if (ret<0)
+	ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
+				    0, &sent);
+	if (ret < 0)
 		goto abort;
 
 	/* wait for the reply to completely arrive */
-	bp = rxrpc_call_alloc_scratch(call,220);
+	bp = rxrpc_call_alloc_scratch(call, 220);
 
-	ret = rxrpc_call_read_data(call,bp,220,RXRPC_CALL_READ_BLOCK|RXRPC_CALL_READ_ALL);
-	if (ret<0) {
-		if (ret==-ECONNABORTED) {
+	ret = rxrpc_call_read_data(call, bp, 220,
+				   RXRPC_CALL_READ_BLOCK |
+				   RXRPC_CALL_READ_ALL);
+	if (ret < 0) {
+		if (ret == -ECONNABORTED) {
 			ret = call->app_errno;
 			goto out_unwait;
 		}
@@ -752,30 +773,30 @@
 	vnode->status.mtime_server	= ntohl(*bp++);
 	bp++; /* group */
 	bp++; /* sync counter */
-	vnode->status.version		|= ((unsigned long long) ntohl(*bp++)) << 32;
+	vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
 	bp++; /* spare2 */
 	bp++; /* spare3 */
 	bp++; /* spare4 */
 
 	dir->status.if_version		= ntohl(*bp++);
-	dir->status.type			= ntohl(*bp++);
+	dir->status.type		= ntohl(*bp++);
 	dir->status.nlink		= ntohl(*bp++);
-	dir->status.size			= ntohl(*bp++);
+	dir->status.size		= ntohl(*bp++);
 	dir->status.version		= ntohl(*bp++);
 	dir->status.author		= ntohl(*bp++);
 	dir->status.owner		= ntohl(*bp++);
 	dir->status.caller_access	= ntohl(*bp++);
 	dir->status.anon_access		= ntohl(*bp++);
-	dir->status.mode			= ntohl(*bp++);
+	dir->status.mode		= ntohl(*bp++);
 	dir->status.parent.vid		= dirfid->vid;
-	dir->status.parent.vnode		= ntohl(*bp++);
+	dir->status.parent.vnode	= ntohl(*bp++);
 	dir->status.parent.unique	= ntohl(*bp++);
 	bp++; /* seg size */
-	dir->status.mtime_client		= ntohl(*bp++);
-	dir->status.mtime_server		= ntohl(*bp++);
+	dir->status.mtime_client	= ntohl(*bp++);
+	dir->status.mtime_server	= ntohl(*bp++);
 	bp++; /* group */
 	bp++; /* sync counter */
-	dir->status.version		|= ((unsigned long long) ntohl(*bp++)) << 32;
+	dir->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
 	bp++; /* spare2 */
 	bp++; /* spare3 */
 	bp++; /* spare4 */
@@ -799,17 +820,17 @@
 
  out_unwait:
 	set_current_state(TASK_RUNNING);
-	remove_wait_queue(&call->waitq,&myself);
+	remove_wait_queue(&call->waitq, &myself);
 	rxrpc_put_call(call);
  out_put_conn:
-	afs_server_release_fsconn(server,conn);
+	afs_server_release_fsconn(server, conn);
  out:
 	kleave("");
 	return ret;
 
  abort:
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	rxrpc_call_abort(call,ret);
+	rxrpc_call_abort(call, ret);
 	schedule();
 	goto out_unwait;
 } /* end afs_rxfs_lookup() */

Index: file.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/file.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -r1.11 -r1.12
--- file.c	10 Sep 2003 08:23:16 -0000	1.11
+++ file.c	10 Sep 2003 13:32:37 -0000	1.12
@@ -31,7 +31,8 @@
 static int afs_file_invalidatepage(struct page *page, unsigned long offset);
 static int afs_file_releasepage(struct page *page, int gfp_flags);
 
-static ssize_t afs_file_write(struct file *file, const char *buf, size_t size, loff_t *off);
+static ssize_t afs_file_write(struct file *file, const char *buf, size_t size,
+			      loff_t *off);
 
 struct inode_operations afs_file_inode_operations = {
 	.getattr	= afs_inode_getattr,
@@ -60,9 +61,10 @@
 /*
  * AFS file write
  */
-static ssize_t afs_file_write(struct file *file, const char *buf, size_t size, loff_t *off)
+static ssize_t afs_file_write(struct file *file, const char *buf, size_t size,
+			      loff_t *off)
 {
-	afs_vnode_t *vnode;
+	struct afs_vnode *vnode;
 
 	vnode = AFS_FS_I(file->f_dentry->d_inode);
 	if (vnode->flags & AFS_VNODE_DELETED)
@@ -76,10 +78,12 @@
  * deal with notification that a page was read from the cache
  */
 #ifdef AFS_CACHING_SUPPORT
-static void afs_file_readpage_read_complete(void *cookie_data, struct page *page, void *data,
+static void afs_file_readpage_read_complete(void *cookie_data,
+					    struct page *page,
+					    void *data,
 					    int error)
 {
-	_enter("%p,%p,%p,%d",cookie_data,page,data,error);
+	_enter("%p,%p,%p,%d", cookie_data, page, data, error);
 
 	if (error)
 		SetPageError(page);
@@ -95,10 +99,12 @@
  * deal with notification that a page was written to the cache
  */
 #ifdef AFS_CACHING_SUPPORT
-static void afs_file_readpage_write_complete(void *cookie_data, struct page *page, void *data,
+static void afs_file_readpage_write_complete(void *cookie_data,
+					     struct page *page,
+					     void *data,
 					     int error)
 {
-	_enter("%p,%p,%p,%d",cookie_data,page,data,error);
+	_enter("%p,%p,%p,%d", cookie_data, page, data, error);
 
 	unlock_page(page);
 
@@ -115,13 +121,13 @@
 #ifdef AFS_CACHING_SUPPORT
 	struct cachefs_page *pageio;
 #endif
+	struct afs_vnode *vnode;
 	struct inode *inode;
-	afs_vnode_t *vnode;
 	int ret;
 
 	inode = page->mapping->host;
 
-	_enter("{%lu},{%lu}",inode->i_ino,page->index);
+	_enter("{%lu},{%lu}", inode->i_ino, page->index);
 
 	vnode = AFS_FS_I(inode);
 
@@ -133,8 +139,8 @@
 		goto error;
 
 #ifdef AFS_CACHING_SUPPORT
-	ret = cachefs_page_get_private(page,&pageio,GFP_NOIO);
-	if (ret<0)
+	ret = cachefs_page_get_private(page, &pageio, GFP_NOIO);
+	if (ret < 0)
 		goto error;
 
 	/* is it cached? */
@@ -162,23 +168,26 @@
 	default:
 		desc.fid	= vnode->fid;
 		desc.offset	= page->index << PAGE_CACHE_SHIFT;
-		desc.size	= min((size_t)(inode->i_size - desc.offset),(size_t)PAGE_SIZE);
+		desc.size	= min((size_t) (inode->i_size - desc.offset),
+				      (size_t) PAGE_SIZE);
 		desc.buffer	= kmap(page);
 
 		clear_page(desc.buffer);
 
-		/* read the contents of the file from the server into the page */
-		ret = afs_vnode_fetch_data(vnode,&desc);
+		/* read the contents of the file from the server into the
+		 * page */
+		ret = afs_vnode_fetch_data(vnode, &desc);
 		kunmap(page);
-		if (ret<0) {
+		if (ret < 0) {
 			if (ret==-ENOENT) {
-				_debug("got NOENT from server - marking file deleted and stale");
+				_debug("got NOENT from server"
+				       " - marking file deleted and stale");
 				vnode->flags |= AFS_VNODE_DELETED;
 				ret = -ESTALE;
 			}
 
 #ifdef AFS_CACHING_SUPPORT
-			cachefs_uncache_page(vnode->cache,page);
+			cachefs_uncache_page(vnode->cache, page);
 #endif
 			goto error;
 		}
@@ -192,7 +201,7 @@
 				       NULL,
 				       GFP_KERNEL) != 0
 		    ) {
-			cachefs_uncache_page(vnode->cache,page);
+			cachefs_uncache_page(vnode->cache, page);
 			unlock_page(page);
 		}
 #else
@@ -207,7 +216,7 @@
 	SetPageError(page);
 	unlock_page(page);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_file_readpage() */
@@ -217,14 +226,15 @@
  * get a page cookie for the specified page
  */
 #ifdef AFS_CACHING_SUPPORT
-int afs_cache_get_page_cookie(struct page *page, struct cachefs_page **_page_cookie)
+int afs_cache_get_page_cookie(struct page *page,
+			      struct cachefs_page **_page_cookie)
 {
 	int ret;
 
 	_enter("");
-	ret = cachefs_page_get_private(page,_page_cookie,GFP_NOIO);
+	ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_cache_get_page_cookie() */
 #endif
@@ -237,30 +247,32 @@
 {
 	int ret = 1;
 
-	_enter("{%lu},%lu",page->index,offset);
+	_enter("{%lu},%lu", page->index, offset);
 
 	BUG_ON(!PageLocked(page));
+
 	if (PagePrivate(page)) {
 #ifdef AFS_CACHING_SUPPORT
 		struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 		cachefs_uncache_page(vnode->cache,page);
 #endif
 
-		/*
-		 * We release buffers only if the entire page is being invalidated.
-		 * The get_block cached value has been unconditionally invalidated,
-		 * so real IO is not possible anymore.
+		/* We release buffers only if the entire page is being
+		 * invalidated.
+		 * The get_block cached value has been unconditionally
+		 * invalidated, so real IO is not possible anymore.
 		 */
 		if (offset == 0) {
 			BUG_ON(!PageLocked(page));
 
 			ret = 0;
 			if (!PageWriteback(page))
-				ret = page->mapping->a_ops->releasepage(page, 0);
+				ret = page->mapping->a_ops->releasepage(page,
+									0);
 		}
 	}
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_file_invalidatepage() */
 
@@ -272,12 +284,12 @@
 {
 	struct cachefs_page *pageio;
 
-	_enter("{%lu},%x",page->index,gfp_flags);
+	_enter("{%lu},%x", page->index, gfp_flags);
 
 	if (PagePrivate(page)) {
 #ifdef AFS_CACHING_SUPPORT
 		struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
-		cachefs_uncache_page(vnode->cache,page);
+		cachefs_uncache_page(vnode->cache, page);
 #endif
 
 		pageio = (struct cachefs_page *) page->private;

Index: dir.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/dir.c,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -r1.12 -r1.13
--- dir.c	10 Sep 2003 08:23:16 -0000	1.12
+++ dir.c	10 Sep 2003 13:32:37 -0000	1.13
@@ -29,8 +29,8 @@
 static int afs_dir_readdir(struct file *file, void *dirent, filldir_t filldir);
 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
 static int afs_d_delete(struct dentry *dentry);
-static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen, loff_t fpos,
-				     ino_t ino, unsigned dtype);
+static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen,
+				  loff_t fpos, ino_t ino, unsigned dtype);
 
 struct file_operations afs_dir_file_operations = {
 	.open		= afs_dir_open,
@@ -61,51 +61,53 @@
 #define AFS_DIR_DIRENT_SIZE	32
 #define AFS_DIRENT_PER_BLOCK	64
 
-typedef union afs_dirent {
+union afs_dirent {
 	struct {
-		u8	valid;
-		u8	unused[1];
-		u16	hash_next;
-		u32	vnode;
-		u32	unique;
-		u8	name[16];
-		u8	overflow[4];	/* if any char of the name (inc NUL) reaches here, consume
-					 * the next dirent too */
+		uint8_t		valid;
+		uint8_t		unused[1];
+		uint16_t	hash_next;
+		uint32_t	vnode;
+		uint32_t	unique;
+		uint8_t		name[16];
+		uint8_t		overflow[4];	/* if any char of the name (inc
+						 * NUL) reaches here, consume
+						 * the next dirent too */
 	} u;
-	u8	extended_name[32];
-} afs_dirent_t;
+	uint8_t	extended_name[32];
+};
 
 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */
-typedef struct afs_dir_pagehdr {
-	u16	npages;
-	u16	magic;
+struct afs_dir_pagehdr {
+	uint16_t	npages;
+	uint16_t	magic;
 #define AFS_DIR_MAGIC htons(1234)
-	u8	nentries;
-	u8	bitmap[8];
-	u8	pad[19];
-} afs_dir_pagehdr_t;
+	uint8_t		nentries;
+	uint8_t		bitmap[8];
+	uint8_t		pad[19];
+};
 
 /* directory block layout */
-typedef union afs_dir_block {
+union afs_dir_block {
 
-	afs_dir_pagehdr_t pagehdr;
+	struct afs_dir_pagehdr pagehdr;
 
 	struct {
-		afs_dir_pagehdr_t pagehdr;
-		u8		alloc_ctrs[128];
-		u16		hashtable[AFS_DIR_HASHTBL_SIZE]; /* dir hash table */
+		struct afs_dir_pagehdr	pagehdr;
+		uint8_t			alloc_ctrs[128];
+		/* dir hash table */
+		uint16_t		hashtable[AFS_DIR_HASHTBL_SIZE];
 	} hdr;
 
-	afs_dirent_t dirents[AFS_DIRENT_PER_BLOCK];
-} afs_dir_block_t;
+	union afs_dirent dirents[AFS_DIRENT_PER_BLOCK];
+};
 
 /* layout on a linux VM page */
-typedef struct afs_dir_page {
-	afs_dir_block_t	blocks[PAGE_SIZE/sizeof(afs_dir_block_t)];
-} afs_dir_page_t;
+struct afs_dir_page {
+	union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)];
+};
 
 struct afs_dir_lookup_cookie {
-	afs_fid_t	fid;
+	struct afs_fid	fid;
 	const char	*name;
 	size_t		nlen;
 	int		found;
@@ -117,14 +119,14 @@
  */
 static inline void afs_dir_check_page(struct inode *dir, struct page *page)
 {
-	afs_dir_page_t *dbuf;
+	struct afs_dir_page *dbuf;
 	loff_t latter;
 	int tmp, qty;
 
 #if 0
 	/* check the page count */
-	qty = desc.size/sizeof(dbuf->blocks[0]);
-	if (qty==0)
+	qty = desc.size / sizeof(dbuf->blocks[0]);
+	if (qty == 0)
 		goto error;
 
 	if (page->index==0 && qty!=ntohs(dbuf->blocks[0].pagehdr.npages)) {
@@ -140,15 +142,15 @@
 		qty = PAGE_SIZE;
 	else
 		qty = latter;
-	qty /= sizeof(afs_dir_block_t);
+	qty /= sizeof(union afs_dir_block);
 
 	/* check them */
 	dbuf = page_address(page);
-	for (tmp=0; tmp<qty; tmp++) {
+	for (tmp = 0; tmp < qty; tmp++) {
 		if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) {
 			printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n",
-			       __FUNCTION__,dir->i_ino,tmp,
-			       qty,ntohs(dbuf->blocks[tmp].pagehdr.magic));
+			       __FUNCTION__, dir->i_ino, tmp, qty,
+			       ntohs(dbuf->blocks[tmp].pagehdr.magic));
 			goto error;
 		}
 	}
@@ -181,17 +183,18 @@
 {
 	struct page *page;
 
-	_enter("{%lu},%lu",dir->i_ino,index);
+	_enter("{%lu},%lu", dir->i_ino, index);
 
 	page = read_cache_page(dir->i_mapping,index,
-			       (filler_t*)dir->i_mapping->a_ops->readpage,NULL);
+			       (filler_t *) dir->i_mapping->a_ops->readpage,
+			       NULL);
 	if (!IS_ERR(page)) {
 		wait_on_page_locked(page);
 		kmap(page);
 		if (!PageUptodate(page))
 			goto fail;
 		if (!PageChecked(page))
-			afs_dir_check_page(dir,page);
+			afs_dir_check_page(dir, page);
 		if (PageError(page))
 			goto fail;
 	}
@@ -208,10 +211,10 @@
  */
 static int afs_dir_open(struct inode *inode, struct file *file)
 {
-	_enter("{%lu}",inode->i_ino);
+	_enter("{%lu}", inode->i_ino);
 
-	if (sizeof(afs_dir_block_t) != 2048) BUG();
-	if (sizeof(afs_dirent_t) != 32) BUG();
+	BUG_ON(sizeof(union afs_dir_block) != 2048);
+	BUG_ON(sizeof(union afs_dirent) != 32);
 
 	if (AFS_FS_I(inode)->flags & AFS_VNODE_DELETED)
 		return -ENOENT;
@@ -226,19 +229,19 @@
  * deal with one block in an AFS directory
  */
 static int afs_dir_iterate_block(unsigned *fpos,
-				    afs_dir_block_t *block,
-				    unsigned blkoff,
-				    void *cookie,
-				    filldir_t filldir)
+				 union afs_dir_block *block,
+				 unsigned blkoff,
+				 void *cookie,
+				 filldir_t filldir)
 {
-	afs_dirent_t *dire;
+	union afs_dirent *dire;
 	unsigned offset, next, curr;
 	size_t nlen;
 	int tmp, ret;
 
 	_enter("%u,%x,%p,,",*fpos,blkoff,block);
 
-	curr = (*fpos - blkoff) / sizeof(afs_dirent_t);
+	curr = (*fpos - blkoff) / sizeof(union afs_dirent);
 
 	/* walk through the block, an entry at a time */
 	for (offset = AFS_DIRENT_PER_BLOCK - block->pagehdr.nentries;
@@ -248,58 +251,70 @@
 		next = offset + 1;
 
 		/* skip entries marked unused in the bitmap */
-		if (!(block->pagehdr.bitmap[offset/8] & (1 << (offset % 8)))) {
-			_debug("ENT[%Zu.%u]: unused\n",blkoff/sizeof(afs_dir_block_t),offset);
-			if (offset>=curr)
-				*fpos = blkoff + next * sizeof(afs_dirent_t);
+		if (!(block->pagehdr.bitmap[offset / 8] &
+		      (1 << (offset % 8)))) {
+			_debug("ENT[%Zu.%u]: unused\n",
+			       blkoff / sizeof(union afs_dir_block), offset);
+			if (offset >= curr)
+				*fpos = blkoff +
+					next * sizeof(union afs_dirent);
 			continue;
 		}
 
 		/* got a valid entry */
 		dire = &block->dirents[offset];
-		nlen = strnlen(dire->u.name,sizeof(*block) - offset*sizeof(afs_dirent_t));
+		nlen = strnlen(dire->u.name,
+			       sizeof(*block) -
+			       offset * sizeof(union afs_dirent));
 
 		_debug("ENT[%Zu.%u]: %s %Zu \"%s\"\n",
-		       blkoff/sizeof(afs_dir_block_t),offset,
-		       (offset<curr ? "skip" : "fill"),
-		       nlen,dire->u.name);
+		       blkoff / sizeof(union afs_dir_block), offset,
+		       (offset < curr ? "skip" : "fill"),
+		       nlen, dire->u.name);
 
 		/* work out where the next possible entry is */
-		for (tmp=nlen; tmp>15; tmp-=sizeof(afs_dirent_t)) {
-			if (next>=AFS_DIRENT_PER_BLOCK) {
+		for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) {
+			if (next >= AFS_DIRENT_PER_BLOCK) {
 				_debug("ENT[%Zu.%u]:"
-				       " %u travelled beyond end dir block (len %u/%Zu)\n",
-				       blkoff/sizeof(afs_dir_block_t),offset,next,tmp,nlen);
+				       " %u travelled beyond end dir block"
+				       " (len %u/%Zu)\n",
+				       blkoff / sizeof(union afs_dir_block),
+				       offset, next, tmp, nlen);
 				return -EIO;
 			}
-			if (!(block->pagehdr.bitmap[next/8] & (1 << (next % 8)))) {
-				_debug("ENT[%Zu.%u]: %u unmarked extension (len %u/%Zu)\n",
-				       blkoff/sizeof(afs_dir_block_t),offset,next,tmp,nlen);
+			if (!(block->pagehdr.bitmap[next / 8] &
+			      (1 << (next % 8)))) {
+				_debug("ENT[%Zu.%u]:"
+				       " %u unmarked extension (len %u/%Zu)\n",
+				       blkoff / sizeof(union afs_dir_block),
+				       offset, next, tmp, nlen);
 				return -EIO;
 			}
 
 			_debug("ENT[%Zu.%u]: ext %u/%Zu\n",
-			       blkoff/sizeof(afs_dir_block_t),next,tmp,nlen);
+			       blkoff / sizeof(union afs_dir_block),
+			       next, tmp, nlen);
 			next++;
 		}
 
 		/* skip if starts before the current position */
-		if (offset<curr)
+		if (offset < curr)
 			continue;
 
 		/* found the next entry */
 		ret = filldir(cookie,
 			      dire->u.name,
 			      nlen,
-			      blkoff + offset * sizeof(afs_dirent_t),
+			      blkoff + offset * sizeof(union afs_dirent),
 			      ntohl(dire->u.vnode),
-			      filldir==afs_dir_lookup_filldir ? dire->u.unique : DT_UNKNOWN);
-		if (ret<0) {
+			      filldir == afs_dir_lookup_filldir ?
+			      dire->u.unique : DT_UNKNOWN);
+		if (ret < 0) {
 			_leave(" = 0 [full]");
 			return 0;
 		}
 
-		*fpos = blkoff + next * sizeof(afs_dirent_t);
+		*fpos = blkoff + next * sizeof(union afs_dirent);
 	}
 
 	_leave(" = 1 [more]");
@@ -310,15 +325,16 @@
 /*
  * read an AFS directory
  */
-static int afs_dir_iterate(struct inode *dir, unsigned *fpos, void *cookie, filldir_t filldir)
+static int afs_dir_iterate(struct inode *dir, unsigned *fpos, void *cookie,
+			   filldir_t filldir)
 {
-	afs_dir_block_t	*dblock;
-	afs_dir_page_t *dbuf;
+	union afs_dir_block	*dblock;
+	struct afs_dir_page *dbuf;
 	struct page *page;
 	unsigned blkoff, limit;
 	int ret;
 
-	_enter("{%lu},%u,,",dir->i_ino,*fpos);
+	_enter("{%lu},%u,,", dir->i_ino, *fpos);
 
 	if (AFS_FS_I(dir)->flags & AFS_VNODE_DELETED) {
 		_leave(" = -ESTALE");
@@ -326,35 +342,37 @@
 	}
 
 	/* round the file position up to the next entry boundary */
-	*fpos += sizeof(afs_dirent_t) - 1;
-	*fpos &= ~(sizeof(afs_dirent_t) - 1);
+	*fpos += sizeof(union afs_dirent) - 1;
+	*fpos &= ~(sizeof(union afs_dirent) - 1);
 
 	/* walk through the blocks in sequence */
 	ret = 0;
 	while (*fpos < dir->i_size) {
-		blkoff = *fpos & ~(sizeof(afs_dir_block_t) - 1);
+		blkoff = *fpos & ~(sizeof(union afs_dir_block) - 1);
 
 		/* fetch the appropriate page from the directory */
-		page = afs_dir_get_page(dir,blkoff/PAGE_SIZE);
+		page = afs_dir_get_page(dir, blkoff / PAGE_SIZE);
 		if (IS_ERR(page)) {
 			ret = PTR_ERR(page);
 			break;
 		}
 
-		limit = blkoff & ~(PAGE_SIZE-1);
+		limit = blkoff & ~(PAGE_SIZE - 1);
 
 		dbuf = page_address(page);
 
 		/* deal with the individual blocks stashed on this page */
 		do {
-			dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) / sizeof(afs_dir_block_t)];
-			ret = afs_dir_iterate_block(fpos,dblock,blkoff,cookie,filldir);
-			if (ret!=1) {
+			dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) /
+					       sizeof(union afs_dir_block)];
+			ret = afs_dir_iterate_block(fpos, dblock, blkoff,
+						    cookie, filldir);
+			if (ret != 1) {
 				afs_dir_put_page(page);
 				goto out;
 			}
 
-			blkoff += sizeof(afs_dir_block_t);
+			blkoff += sizeof(union afs_dir_block);
 
 		} while (*fpos < dir->i_size && blkoff < limit);
 
@@ -363,7 +381,7 @@
 	}
 
  out:
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_dir_iterate() */
 
@@ -376,29 +394,31 @@
 	unsigned fpos;
 	int ret;
 
-	_enter("{%Ld,{%lu}}",file->f_pos,file->f_dentry->d_inode->i_ino);
+	_enter("{%Ld,{%lu}}", file->f_pos, file->f_dentry->d_inode->i_ino);
 
 	fpos = file->f_pos;
-	ret = afs_dir_iterate(file->f_dentry->d_inode,&fpos,cookie,filldir);
+	ret = afs_dir_iterate(file->f_dentry->d_inode, &fpos, cookie, filldir);
 	file->f_pos = fpos;
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 } /* end afs_dir_readdir() */
 
 /*****************************************************************************/
 /*
  * search the directory for a name
- * - if afs_dir_iterate_block() spots this function, it'll pass the FID uniquifier through dtype
+ * - if afs_dir_iterate_block() spots this function, it'll pass the FID
+ *   uniquifier through dtype
  */
-static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen, loff_t fpos,
-				  ino_t ino, unsigned dtype)
+static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen,
+				  loff_t fpos, ino_t ino, unsigned dtype)
 {
 	struct afs_dir_lookup_cookie *cookie = _cookie;
 
-	_enter("{%s,%Zu},%s,%u,,%lu,%u",cookie->name,cookie->nlen,name,nlen,ino,ntohl(dtype));
+	_enter("{%s,%Zu},%s,%u,,%lu,%u",
+	       cookie->name, cookie->nlen, name, nlen, ino, ntohl(dtype));
 
-	if (cookie->nlen != nlen || memcmp(cookie->name,name,nlen)!=0) {
+	if (cookie->nlen != nlen || memcmp(cookie->name, name, nlen) != 0) {
 		_leave(" = 0 [no]");
 		return 0;
 	}
@@ -420,16 +440,16 @@
 {
 	struct afs_dir_lookup_cookie cookie;
 	struct afs_super_info *as;
+	struct afs_vnode *vnode;
 	struct inode *inode;
-	afs_vnode_t *vnode;
 	unsigned fpos;
 	int ret;
 
-	_enter("{%lu},%p{%s}",dir->i_ino,dentry,dentry->d_name.name);
+	_enter("{%lu},%p{%s}", dir->i_ino, dentry, dentry->d_name.name);
 
 	/* insanity checks first */
-	BUG_ON(sizeof(afs_dir_block_t) != 2048);
-	BUG_ON(sizeof(afs_dirent_t) != 32);
+	BUG_ON(sizeof(union afs_dir_block) != 2048);
+	BUG_ON(sizeof(union afs_dirent) != 32);
 
 	if (dentry->d_name.len > 255) {
 		_leave(" = -ENAMETOOLONG");
@@ -451,29 +471,29 @@
 	cookie.found	= 0;
 
 	fpos = 0;
-	ret = afs_dir_iterate(dir,&fpos,&cookie,afs_dir_lookup_filldir);
-	if (ret<0) {
-		_leave(" = %d",ret);
+	ret = afs_dir_iterate(dir, &fpos, &cookie, afs_dir_lookup_filldir);
+	if (ret < 0) {
+		_leave(" = %d", ret);
 		return ERR_PTR(ret);
 	}
 
 	ret = -ENOENT;
 	if (!cookie.found) {
-		_leave(" = %d",ret);
+		_leave(" = %d", ret);
 		return ERR_PTR(ret);
 	}
 
 	/* instantiate the dentry */
-	ret = afs_iget(dir->i_sb,&cookie.fid,&inode);
-	if (ret<0) {
-		_leave(" = %d",ret);
+	ret = afs_iget(dir->i_sb, &cookie.fid, &inode);
+	if (ret < 0) {
+		_leave(" = %d", ret);
 		return ERR_PTR(ret);
 	}
 
 	dentry->d_op = &afs_fs_dentry_operations;
-	dentry->d_fsdata = (void*) (unsigned long) vnode->status.version;
+	dentry->d_fsdata = (void *) (unsigned long) vnode->status.version;
 
-	d_add(dentry,inode);
+	d_add(dentry, inode);
 	_leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%lu }",
 	       cookie.fid.vnode,
 	       cookie.fid.unique,
@@ -486,7 +506,8 @@
 /*****************************************************************************/
 /*
  * check that a dentry lookup hit has found a valid entry
- * - NOTE! the hit can be a negative hit too, so we can't assume we have an inode
+ * - NOTE! the hit can be a negative hit too, so we can't assume we have an
+ *   inode
  * (derived from nfs_lookup_revalidate)
  */
 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
@@ -497,7 +518,7 @@
 	unsigned fpos;
 	int ret;
 
-	_enter("{sb=%p n=%s},",dentry->d_sb,dentry->d_name.name);
+	_enter("{sb=%p n=%s},", dentry->d_sb, dentry->d_name.name);
 
 	/* lock down the parent dentry so we can peer at it */
 	parent = dget_parent(dentry->d_parent);
@@ -505,39 +526,41 @@
 	dir = parent->d_inode;
 	inode = dentry->d_inode;
 
-	/* handle a negative inode */
+	/* handle a negative dentry */
 	if (!inode)
 		goto out_bad;
 
 	/* handle a bad inode */
 	if (is_bad_inode(inode)) {
 		printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n",
-		       dentry->d_parent->d_name.name,dentry->d_name.name);
+		       dentry->d_parent->d_name.name, dentry->d_name.name);
 		goto out_bad;
 	}
 
-	/* force a full look up if the parent directory changed since last the server was consulted
-	 * - otherwise this inode must still exist, even if the inode details themselves have
-	 *   changed
+	/* force a full look up if the parent directory changed since last the
+	 * server was consulted
+	 * - otherwise this inode must still exist, even if the inode details
+	 *   themselves have changed
 	 */
 	if (AFS_FS_I(dir)->flags & AFS_VNODE_CHANGED)
 		afs_vnode_fetch_status(AFS_FS_I(dir));
 
 	if (AFS_FS_I(dir)->flags & AFS_VNODE_DELETED) {
-		_debug("%s: parent dir deleted",dentry->d_name.name);
+		_debug("%s: parent dir deleted", dentry->d_name.name);
 		goto out_bad;
 	}
 
 	if (AFS_FS_I(inode)->flags & AFS_VNODE_DELETED) {
-		_debug("%s: file already deleted",dentry->d_name.name);
+		_debug("%s: file already deleted", dentry->d_name.name);
 		goto out_bad;
 	}
 
-	if ((unsigned long)dentry->d_fsdata != (unsigned long)AFS_FS_I(dir)->status.version) {
+	if ((unsigned long) dentry->d_fsdata !=
+	    (unsigned long) AFS_FS_I(dir)->status.version) {
 		_debug("%s: parent changed %lu -> %u",
 		       dentry->d_name.name,
-		       (unsigned long)dentry->d_fsdata,
-		       (unsigned)AFS_FS_I(dir)->status.version);
+		       (unsigned long) dentry->d_fsdata,
+		       (unsigned) AFS_FS_I(dir)->status.version);
 
 		/* search the directory for this vnode */
 		cookie.name	= dentry->d_name.name;
@@ -546,25 +569,29 @@
 		cookie.found	= 0;
 
 		fpos = 0;
-		ret = afs_dir_iterate(dir,&fpos,&cookie,afs_dir_lookup_filldir);
-		if (ret<0) {
-			_debug("failed to iterate dir %s: %d",parent->d_name.name,ret);
+		ret = afs_dir_iterate(dir, &fpos, &cookie,
+				      afs_dir_lookup_filldir);
+		if (ret < 0) {
+			_debug("failed to iterate dir %s: %d",
+			       parent->d_name.name, ret);
 			goto out_bad;
 		}
 
 		if (!cookie.found) {
-			_debug("%s: dirent not found",dentry->d_name.name);
+			_debug("%s: dirent not found", dentry->d_name.name);
 			goto not_found;
 		}
 
-		/* if the vnode ID has changed, then the dirent points to a different file */
-		if (cookie.fid.vnode!=AFS_FS_I(inode)->fid.vnode) {
-			_debug("%s: dirent changed",dentry->d_name.name);
+		/* if the vnode ID has changed, then the dirent points to a
+		 * different file */
+		if (cookie.fid.vnode != AFS_FS_I(inode)->fid.vnode) {
+			_debug("%s: dirent changed", dentry->d_name.name);
 			goto not_found;
 		}
 
-		/* if the vnode ID uniqifier has changed, then the file has been deleted */
-		if (cookie.fid.unique!=AFS_FS_I(inode)->fid.unique) {
+		/* if the vnode ID uniqifier has changed, then the file has
+		 * been deleted */
+		if (cookie.fid.unique != AFS_FS_I(inode)->fid.unique) {
 			_debug("%s: file deleted (uq %u -> %u I:%lu)",
 			       dentry->d_name.name,
 			       cookie.fid.unique,
@@ -577,7 +604,8 @@
 			goto out_bad;
 		}
 
-		dentry->d_fsdata = (void*) (unsigned long) AFS_FS_I(dir)->status.version;
+		dentry->d_fsdata =
+			(void *) (unsigned long) AFS_FS_I(dir)->status.version;
 	}
 
  out_valid:
@@ -598,7 +626,8 @@
 
 	shrink_dcache_parent(dentry);
 
-	_debug("dropping dentry %s/%s",dentry->d_parent->d_name.name,dentry->d_name.name);
+	_debug("dropping dentry %s/%s",
+	       dentry->d_parent->d_name.name, dentry->d_name.name);
 	d_drop(dentry);
 
 	dput(parent);
@@ -609,13 +638,14 @@
 
 /*****************************************************************************/
 /*
- * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't sleep)
+ * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
+ * sleep)
  * - called from dput() when d_count is going to 0.
  * - return 1 to request dentry be unhashed, 0 otherwise
  */
 static int afs_d_delete(struct dentry *dentry)
 {
-	_enter("%s",dentry->d_name.name);
+	_enter("%s", dentry->d_name.name);
 
 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
 		goto zap;

Index: cmservice.h
===================================================================
RCS file: /home/cvs/afs/fs/afs/cmservice.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -r1.1.1.1 -r1.2
--- cmservice.h	19 Jun 2002 13:34:05 -0000	1.1.1.1
+++ cmservice.h	10 Sep 2003 13:32:37 -0000	1.2
@@ -20,8 +20,10 @@
 extern void afscm_stop(void);
 
 /* cache manager server functions */
-extern int SRXAFSCM_InitCallBackState(afs_server_t *server);
-extern int SRXAFSCM_CallBack(afs_server_t *server, size_t count, afs_callback_t callbacks[]);
-extern int SRXAFSCM_Probe(afs_server_t *server);
+extern int SRXAFSCM_InitCallBackState(struct afs_server *server);
+extern int SRXAFSCM_CallBack(struct afs_server *server,
+			     size_t count,
+			     struct afs_callback callbacks[]);
+extern int SRXAFSCM_Probe(struct afs_server *server);
 
 #endif /* _LINUX_AFS_CMSERVICE_H */

Index: cmservice.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/cmservice.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -r1.10 -r1.11
--- cmservice.c	10 Sep 2003 08:23:16 -0000	1.10
+++ cmservice.c	10 Sep 2003 13:32:37 -0000	1.11
@@ -94,7 +94,7 @@
 	.error_func	= afscm_error,
 	.aemap_func	= afscm_aemap,
 	.ops_begin	= &AFSCM_ops[0],
-	.ops_end	= &AFSCM_ops[sizeof(AFSCM_ops)/sizeof(AFSCM_ops[0])],
+	.ops_end	= &AFSCM_ops[sizeof(AFSCM_ops) / sizeof(AFSCM_ops[0])],
 };
 
 static DECLARE_COMPLETION(kafscmd_alive);
@@ -112,13 +112,13 @@
  */
 static int kafscmd(void *arg)
 {
-	DECLARE_WAITQUEUE(myself,current);
+	DECLARE_WAITQUEUE(myself, current);
 
 	struct rxrpc_call *call;
 	_SRXAFSCM_xxxx_t func;
 	int die;
 
-	printk("kAFS: Started kafscmd %d\n",current->pid);
+	printk("kAFS: Started kafscmd %d\n", current->pid);
 
 	daemonize("kafscmd");
 
@@ -128,7 +128,7 @@
 	do {
 		if (list_empty(&kafscmd_attention_list)) {
 			set_current_state(TASK_INTERRUPTIBLE);
-			add_wait_queue(&kafscmd_sleepq,&myself);
+			add_wait_queue(&kafscmd_sleepq, &myself);
 
 			for (;;) {
 				set_current_state(TASK_INTERRUPTIBLE);
@@ -140,7 +140,7 @@
 				schedule();
 			}
 
-			remove_wait_queue(&kafscmd_sleepq,&myself);
+			remove_wait_queue(&kafscmd_sleepq, &myself);
 			set_current_state(TASK_RUNNING);
 		}
 
@@ -162,7 +162,7 @@
 
 		if (call) {
 			/* act upon it */
-			_debug("@@@ Begin Attend Call %p",call);
+			_debug("@@@ Begin Attend Call %p", call);
 
 			func = call->app_user;
 			if (func)
@@ -170,13 +170,13 @@
 
 			rxrpc_put_call(call);
 
-			_debug("@@@ End Attend Call %p",call);
+			_debug("@@@ End Attend Call %p", call);
 		}
 
 	} while(!die);
 
 	/* and that's all */
-	complete_and_exit(&kafscmd_dead,0);
+	complete_and_exit(&kafscmd_dead, 0);
 
 } /* end kafscmd() */
 
@@ -184,12 +184,14 @@
 /*
  * handle a call coming in to the cache manager
  * - if I want to keep the call, I must increment its usage count
- * - the return value will be negated and passed back in an abort packet if non-zero
+ * - the return value will be negated and passed back in an abort packet if
+ *   non-zero
  * - serialised by virtue of there only being one krxiod
  */
 static int afscm_new_call(struct rxrpc_call *call)
 {
-	_enter("%p{cid=%u u=%d}",call,ntohl(call->call_id),atomic_read(&call->usage));
+	_enter("%p{cid=%u u=%d}",
+	       call, ntohl(call->call_id), atomic_read(&call->usage));
 
 	rxrpc_get_call(call);
 
@@ -209,12 +211,13 @@
  */
 static void afscm_attention(struct rxrpc_call *call)
 {
-	_enter("%p{cid=%u u=%d}",call,ntohl(call->call_id),atomic_read(&call->usage));
+	_enter("%p{cid=%u u=%d}",
+	       call, ntohl(call->call_id), atomic_read(&call->usage));
 
 	spin_lock(&kafscmd_attention_lock);
 
 	if (list_empty(&call->app_attn_link)) {
-		list_add_tail(&call->app_attn_link,&kafscmd_attention_list);
+		list_add_tail(&call->app_attn_link, &kafscmd_attention_list);
 		rxrpc_get_call(call);
 	}
 
@@ -222,7 +225,7 @@
 
 	wake_up(&kafscmd_sleepq);
 
-	_leave(" {u=%d}",atomic_read(&call->usage));
+	_leave(" {u=%d}", atomic_read(&call->usage));
 } /* end afscm_attention() */
 
 /*****************************************************************************/
@@ -243,7 +246,7 @@
 	spin_lock(&kafscmd_attention_lock);
 
 	if (list_empty(&call->app_attn_link)) {
-		list_add_tail(&call->app_attn_link,&kafscmd_attention_list);
+		list_add_tail(&call->app_attn_link, &kafscmd_attention_list);
 		rxrpc_get_call(call);
 	}
 
@@ -301,7 +304,7 @@
 		wait_for_completion(&kafscmd_alive);
 
 		ret = rxrpc_add_service(afs_transport, &AFSCM_service);
-		if (ret<0)
+		if (ret < 0)
 			goto kill;
 
 #ifdef AFS_AUTOMOUNT_SUPPORT
@@ -336,14 +339,15 @@
 
 	down_write(&afscm_sem);
 
-	if (afscm_usage == 0) BUG();
+	BUG_ON(afscm_usage == 0);
 	afscm_usage--;
 
 	if (afscm_usage == 0) {
 		/* don't want more incoming calls */
 		rxrpc_del_service(afs_transport, &AFSCM_service);
 
-		/* abort any calls I've still got open (the afscm_error() will dequeue them) */
+		/* abort any calls I've still got open (the afscm_error() will
+		 * dequeue them) */
 		spin_lock(&afscm_calls_lock);
 		while (!list_empty(&afscm_calls)) {
 			call = list_entry(afscm_calls.next,
@@ -354,7 +358,8 @@
 			rxrpc_get_call(call);
 			spin_unlock(&afscm_calls_lock);
 
-			rxrpc_call_abort(call,-ESRCH); /* abort, dequeue and put */
+			rxrpc_call_abort(call, -ESRCH); /* abort, dequeue and
+							 * put */
 
 			_debug("nuking active call %08x.%d",
 			       ntohl(call->conn->conn_id),
@@ -402,11 +407,11 @@
  */
 static void _SRXAFSCM_CallBack(struct rxrpc_call *call)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	size_t count, qty, tmp;
 	int ret = 0, removed;
 
-	_enter("%p{acs=%s}",call,rxrpc_call_states[call->app_call_state]);
+	_enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]);
 
 	server = afs_server_get_from_peer(call->conn->peer);
 
@@ -417,38 +422,41 @@
 	case RXRPC_CSTATE_SRVR_GOT_ARGS:
 		ret = -EBADMSG;
 		qty = call->app_ready_qty;
-		if (qty<8 || qty>50*(6*4)+8)
+		if (qty < 8 || qty > 50 * (6 * 4) + 8)
 			break;
 
 		{
-			afs_callback_t *cb, *pcb;
+			struct afs_callback *cb, *pcb;
 			int loop;
 			u32 *fp, *bp;
 
-			fp = rxrpc_call_alloc_scratch(call,qty);
+			fp = rxrpc_call_alloc_scratch(call, qty);
 
-			/* drag the entire argument block out to the scratch space */
-			ret = rxrpc_call_read_data(call,fp,qty,0);
-			if (ret<0)
+			/* drag the entire argument block out to the scratch
+			 * space */
+			ret = rxrpc_call_read_data(call, fp, qty, 0);
+			if (ret < 0)
 				break;
 
 			/* and unmarshall the parameter block */
 			ret = -EBADMSG;
 			count = ntohl(*fp++);
 			if (count>AFSCBMAX ||
-			    (count*(3*4)+8 != qty && count*(6*4)+8 != qty))
+			    (count * (3 * 4) + 8 != qty &&
+			     count * (6 * 4) + 8 != qty))
 				break;
 
 			bp = fp + count*3;
 			tmp = ntohl(*bp++);
-			if (tmp>0 && tmp!=count)
+			if (tmp > 0 && tmp != count)
 				break;
-			if (tmp==0)
+			if (tmp == 0)
 				bp = NULL;
 
-			pcb = cb = rxrpc_call_alloc_scratch_s(call,afs_callback_t);
+			pcb = cb = rxrpc_call_alloc_scratch_s(
+				call, struct afs_callback);
 
-			for (loop=count-1; loop>=0; loop--) {
+			for (loop = count - 1; loop >= 0; loop--) {
 				pcb->fid.vid	= ntohl(*fp++);
 				pcb->fid.vnode	= ntohl(*fp++);
 				pcb->fid.unique	= ntohl(*fp++);
@@ -466,14 +474,15 @@
 			}
 
 			/* invoke the actual service routine */
-			ret = SRXAFSCM_CallBack(server,count,cb);
-			if (ret<0)
+			ret = SRXAFSCM_CallBack(server, count, cb);
+			if (ret < 0)
 				break;
 		}
 
 		/* send the reply */
-		ret = rxrpc_call_write_data(call,0,NULL,RXRPC_LAST_PACKET,GFP_KERNEL,0,&count);
-		if (ret<0)
+		ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET,
+					    GFP_KERNEL, 0, &count);
+		if (ret < 0)
 			break;
 		break;
 
@@ -501,12 +510,12 @@
 		break;
 	}
 
-	if (ret<0)
-		rxrpc_call_abort(call,ret);
+	if (ret < 0)
+		rxrpc_call_abort(call, ret);
 
 	afs_put_server(server);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 
 } /* end _SRXAFSCM_CallBack() */
 
@@ -516,16 +525,17 @@
  */
 static void _SRXAFSCM_InitCallBackState(struct rxrpc_call *call)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	size_t count;
 	int ret = 0, removed;
 
-	_enter("%p{acs=%s}",call,rxrpc_call_states[call->app_call_state]);
+	_enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]);
 
 	server = afs_server_get_from_peer(call->conn->peer);
 
 	switch (call->app_call_state) {
-		/* we've received the last packet - drain all the data from the call */
+		/* we've received the last packet - drain all the data from the
+		 * call */
 	case RXRPC_CSTATE_SRVR_GOT_ARGS:
 		/* shouldn't be any args */
 		ret = -EBADMSG;
@@ -535,11 +545,12 @@
 	case RXRPC_CSTATE_SRVR_SND_REPLY:
 		/* invoke the actual service routine */
 		ret = SRXAFSCM_InitCallBackState(server);
-		if (ret<0)
+		if (ret < 0)
 			break;
 
-		ret = rxrpc_call_write_data(call,0,NULL,RXRPC_LAST_PACKET,GFP_KERNEL,0,&count);
-		if (ret<0)
+		ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET,
+					    GFP_KERNEL, 0, &count);
+		if (ret < 0)
 			break;
 		break;
 
@@ -567,12 +578,12 @@
 		break;
 	}
 
-	if (ret<0)
-		rxrpc_call_abort(call,ret);
+	if (ret < 0)
+		rxrpc_call_abort(call, ret);
 
 	afs_put_server(server);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 
 } /* end _SRXAFSCM_InitCallBackState() */
 
@@ -582,16 +593,17 @@
  */
 static void _SRXAFSCM_Probe(struct rxrpc_call *call)
 {
-	afs_server_t *server;
+	struct afs_server *server;
 	size_t count;
 	int ret = 0, removed;
 
-	_enter("%p{acs=%s}",call,rxrpc_call_states[call->app_call_state]);
+	_enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]);
 
 	server = afs_server_get_from_peer(call->conn->peer);
 
 	switch (call->app_call_state) {
-		/* we've received the last packet - drain all the data from the call */
+		/* we've received the last packet - drain all the data from the
+		 * call */
 	case RXRPC_CSTATE_SRVR_GOT_ARGS:
 		/* shouldn't be any args */
 		ret = -EBADMSG;
@@ -601,11 +613,12 @@
 	case RXRPC_CSTATE_SRVR_SND_REPLY:
 		/* invoke the actual service routine */
 		ret = SRXAFSCM_Probe(server);
-		if (ret<0)
+		if (ret < 0)
 			break;
 
-		ret = rxrpc_call_write_data(call,0,NULL,RXRPC_LAST_PACKET,GFP_KERNEL,0,&count);
-		if (ret<0)
+		ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET,
+					    GFP_KERNEL, 0, &count);
+		if (ret < 0)
 			break;
 		break;
 
@@ -633,11 +646,11 @@
 		break;
 	}
 
-	if (ret<0)
-		rxrpc_call_abort(call,ret);
+	if (ret < 0)
+		rxrpc_call_abort(call, ret);
 
 	afs_put_server(server);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 
 } /* end _SRXAFSCM_Probe() */

Index: cell.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/cell.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -r1.13 -r1.14
--- cell.c	10 Sep 2003 08:23:16 -0000	1.13
+++ cell.c	10 Sep 2003 13:32:37 -0000	1.14
@@ -29,20 +29,21 @@
 static struct list_head afs_cells = LIST_HEAD_INIT(afs_cells);
 static rwlock_t afs_cells_lock = RW_LOCK_UNLOCKED;
 static DECLARE_RWSEM(afs_cells_sem); /* add/remove serialisation */
-static afs_cell_t *afs_cell_root;
+static struct afs_cell *afs_cell_root;
 
 static char *rootcell;
 
-MODULE_PARM(rootcell,"s");
-MODULE_PARM_DESC(rootcell,"root AFS cell name and VL server IP addr list");
+MODULE_PARM(rootcell, "s");
+MODULE_PARM_DESC(rootcell, "root AFS cell name and VL server IP addr list");
 
 #ifdef AFS_CACHING_SUPPORT
-static cachefs_match_val_t afs_cell_cache_match(void *target, const void *entry);
+static cachefs_match_val_t afs_cell_cache_match(void *target,
+						const void *entry);
 static void afs_cell_cache_update(void *source, void *entry);
 
 struct cachefs_index_def afs_cache_cell_index_def = {
 	.name			= "cell_ix",
-	.data_size		= sizeof(afs_cell_t),
+	.data_size		= sizeof(struct afs_cache_cell),
 	.keys[0]		= { CACHEFS_INDEX_KEYS_ASCIIZ, 64 },
 	.match			= afs_cell_cache_match,
 	.update			= afs_cell_cache_update,
@@ -55,27 +56,27 @@
  * - "name" is the name of the cell
  * - "vllist" is a colon separated list of IP addresses in "a.b.c.d" format
  */
-int afs_cell_create(const char *name, char *vllist, afs_cell_t **_cell)
+int afs_cell_create(const char *name, char *vllist, struct afs_cell **_cell)
 {
-	afs_cell_t *cell;
+	struct afs_cell *cell;
 	char *next;
 	int ret;
 
-	_enter("%s",name);
+	_enter("%s", name);
 
-	if (!name) BUG(); /* TODO: want to look up "this cell" in the cache */
+	BUG_ON(!name); /* TODO: want to look up "this cell" in the cache */
 
 	down_write(&afs_cells_sem);
 
 	/* allocate and initialise a cell record */
-	cell = kmalloc(sizeof(afs_cell_t) + strlen(name) + 1,GFP_KERNEL);
+	cell = kmalloc(sizeof(struct afs_cell) + strlen(name) + 1, GFP_KERNEL);
 	if (!cell) {
 		_leave(" = -ENOMEM");
 		return -ENOMEM;
 	}
 
-	memset(cell,0,sizeof(afs_cell_t));
-	atomic_set(&cell->usage,0);
+	memset(cell, 0, sizeof(struct afs_cell));
+	atomic_set(&cell->usage, 0);
 
 	INIT_LIST_HEAD(&cell->link);
 
@@ -96,26 +97,27 @@
 	do {
 		unsigned a, b, c, d;
 
-		next = strchr(vllist,':');
-		if (next) *next++ = 0;
+		next = strchr(vllist, ':');
+		if (next)
+			*next++ = 0;
 
-		if (sscanf(vllist,"%u.%u.%u.%u",&a,&b,&c,&d)!=4)
+		if (sscanf(vllist, "%u.%u.%u.%u", &a, &b, &c, &d) != 4)
 			goto badaddr;
 
-		if (a>255 || b>255 || c>255 || d>255)
+		if (a > 255 || b > 255 || c > 255 || d > 255)
 			goto badaddr;
 
 		cell->vl_addrs[cell->vl_naddrs++].s_addr =
-			htonl((a<<24)|(b<<16)|(c<<8)|d);
+			htonl((a << 24) | (b << 16) | (c << 8) | d);
 
 		if (cell->vl_naddrs >= AFS_CELL_MAX_ADDRS)
 			break;
 
-	} while(vllist=next, vllist);
+	} while(vllist = next, vllist);
 
 	/* add a proc dir for this cell */
 	ret = afs_proc_cell_setup(cell);
-	if (ret<0)
+	if (ret < 0)
 		goto error;
 
 #ifdef AFS_CACHING_SUPPORT
@@ -128,21 +130,21 @@
 
 	/* add to the cell lists */
 	write_lock(&afs_cells_lock);
-	list_add_tail(&cell->link,&afs_cells);
+	list_add_tail(&cell->link, &afs_cells);
 	write_unlock(&afs_cells_lock);
 
 	down_write(&afs_proc_cells_sem);
-	list_add_tail(&cell->proc_link,&afs_proc_cells);
+	list_add_tail(&cell->proc_link, &afs_proc_cells);
 	up_write(&afs_proc_cells_sem);
 
 	*_cell = cell;
 	up_write(&afs_cells_sem);
 
-	_leave(" = 0 (%p)",cell);
+	_leave(" = 0 (%p)", cell);
 	return 0;
 
  badaddr:
-	printk("kAFS: bad VL server IP address: '%s'\n",vllist);
+	printk("kAFS: bad VL server IP address: '%s'\n", vllist);
  error:
 	up_write(&afs_cells_sem);
 	kfree(afs_cell_root);
@@ -165,7 +167,7 @@
 		return -EINVAL;
 	}
 
-	cp = strchr(rootcell,':');
+	cp = strchr(rootcell, ':');
 	if (!cp) {
 		printk("kAFS: no VL server IP addresses specified\n");
 		return -EINVAL;
@@ -173,11 +175,11 @@
 
 	/* allocate a cell record for the root cell */
 	*cp++ = 0;
-	ret = afs_cell_create(rootcell,cp,&afs_cell_root);
-	if (ret==0)
+	ret = afs_cell_create(rootcell, cp, &afs_cell_root);
+	if (ret == 0)
 		afs_get_cell(afs_cell_root);
 
-	_leave(" = %d",ret);
+	_leave(" = %d", ret);
 	return ret;
 
 } /* end afs_cell_init() */
@@ -188,8 +190,7 @@
  */
 int afs_cell_lookup(const char *name, unsigned namesz, struct afs_cell **_cell)
 {
-	struct list_head *_p;
-	afs_cell_t *cell;
+	struct afs_cell *cell;
 	int ret;
 
 	_enter("\"%*.*s\",", namesz, namesz, name ? name : "");
@@ -202,8 +203,7 @@
 		cell = NULL;
 		read_lock(&afs_cells_lock);
 
-		list_for_each(_p,&afs_cells) {
-			cell = list_entry(_p, struct afs_cell, link);
+		list_for_each_entry(cell, &afs_cells, link) {
 			if (strncmp(cell->name, name, namesz) == 0) {
 				afs_get_cell(cell);
 				break;
@@ -232,9 +232,9 @@
 /*
  * try and get a cell record
  */
-afs_cell_t *afs_get_cell_maybe(afs_cell_t **_cell)
+struct afs_cell *afs_get_cell_maybe(struct afs_cell **_cell)
 {
-	afs_cell_t *cell;
+	struct afs_cell *cell;
 
 	write_lock(&afs_cells_lock);
 
@@ -253,18 +253,18 @@
 /*
  * destroy a cell record
  */
-void afs_put_cell(afs_cell_t *cell)
+void afs_put_cell(struct afs_cell *cell)
 {
 	if (!cell)
 		return;
 
-	_enter("%p{%d,%s}",cell,atomic_read(&cell->usage),cell->name);
+	_enter("%p{%d,%s}", cell, atomic_read(&cell->usage), cell->name);
 
 	/* sanity check */
-	if (atomic_read(&cell->usage)<=0)
-		BUG();
+	BUG_ON(atomic_read(&cell->usage) <= 0);
 
-	/* to prevent a race, the decrement and the dequeue must be effectively atomic */
+	/* to prevent a race, the decrement and the dequeue must be effectively
+	 * atomic */
 	write_lock(&afs_cells_lock);
 
 	if (likely(!atomic_dec_and_test(&cell->usage))) {
@@ -275,10 +275,10 @@
 
 	write_unlock(&afs_cells_lock);
 
-	if (!list_empty(&cell->sv_list))	BUG();
-	if (!list_empty(&cell->sv_graveyard))	BUG();
-	if (!list_empty(&cell->vl_list))	BUG();
-	if (!list_empty(&cell->vl_graveyard))	BUG();
+	BUG_ON(!list_empty(&cell->sv_list));
+	BUG_ON(!list_empty(&cell->sv_graveyard));
+	BUG_ON(!list_empty(&cell->vl_list));
+	BUG_ON(!list_empty(&cell->vl_graveyard));
 
 	_leave(" [unused]");
 } /* end afs_put_cell() */
@@ -287,16 +287,16 @@
 /*
  * destroy a cell record
  */
-static void afs_cell_destroy(afs_cell_t *cell)
+static void afs_cell_destroy(struct afs_cell *cell)
 {
-	_enter("%p{%d,%s}",cell,atomic_read(&cell->usage),cell->name);
+	_enter("%p{%d,%s}", cell, atomic_read(&cell->usage), cell->name);
 
-	/* to prevent a race, the decrement and the dequeue must be effectively atomic */
+	/* to prevent a race, the decrement and the dequeue must be effectively
+	 * atomic */
 	write_lock(&afs_cells_lock);
 
 	/* sanity check */
-	if (atomic_read(&cell->usage)!=0)
-		BUG();
+	BUG_ON(atomic_read(&cell->usage) != 0);
 
 	list_del_init(&cell->link);
 
@@ -311,15 +311,15 @@
 	up_write(&afs_proc_cells_sem);
 
 #ifdef AFS_CACHING_SUPPORT
-	cachefs_relinquish_cookie(cell->cache,0);
+	cachefs_relinquish_cookie(cell->cache, 0);
 #endif
 
 	up_write(&afs_cells_sem);
 
-	if (!list_empty(&cell->sv_list))	BUG();
-	if (!list_empty(&cell->sv_graveyard))	BUG();
-	if (!list_empty(&cell->vl_list))	BUG();
-	if (!list_empty(&cell->vl_graveyard))	BUG();
+	BUG_ON(!list_empty(&cell->sv_list));
+	BUG_ON(!list_empty(&cell->sv_graveyard));
+	BUG_ON(!list_empty(&cell->vl_list));
+	BUG_ON(!list_empty(&cell->vl_graveyard));
 
 	/* finish cleaning up the cell */
 	kfree(cell);
@@ -331,42 +331,40 @@
 /*
  * lookup the server record corresponding to an Rx RPC peer
  */
-int afs_server_find_by_peer(const struct rxrpc_peer *peer, afs_server_t **_server)
+int afs_server_find_by_peer(const struct rxrpc_peer *peer,
+			    struct afs_server **_server)
 {
-	struct list_head *_pc, *_ps;
-	afs_server_t *server;
-	afs_cell_t *cell;
+	struct afs_server *server;
+	struct afs_cell *cell;
 
-	_enter("%p{a=%08x},",peer,ntohl(peer->addr.s_addr));
+	_enter("%p{a=%08x},", peer, ntohl(peer->addr.s_addr));
 
 	/* search the cell list */
 	read_lock(&afs_cells_lock);
 
-	list_for_each(_pc,&afs_cells) {
-		cell = list_entry(_pc,afs_cell_t,link);
+	list_for_each_entry(cell, &afs_cells, link) {
 
 		_debug("? cell %s",cell->name);
 
 		write_lock(&cell->sv_lock);
 
 		/* check the active list */
-		list_for_each(_ps,&cell->sv_list) {
-			server = list_entry(_ps,afs_server_t,link);
+		list_for_each_entry(server, &cell->sv_list, link) {
+			_debug("?? server %08x", ntohl(server->addr.s_addr));
 
-			_debug("?? server %08x",ntohl(server->addr.s_addr));
-
-			if (memcmp(&server->addr,&peer->addr,sizeof(struct in_addr))==0)
+			if (memcmp(&server->addr, &peer->addr,
+				   sizeof(struct in_addr)) == 0)
 				goto found_server;
 		}
 
 		/* check the inactive list */
 		spin_lock(&cell->sv_gylock);
-		list_for_each(_ps,&cell->sv_graveyard) {
-			server = list_entry(_ps,afs_server_t,link);
-
-			_debug("?? dead server %08x",ntohl(server->addr.s_addr));
+		list_for_each_entry(server, &cell->sv_graveyard, link) {
+			_debug("?? dead server %08x",
+			       ntohl(server->addr.s_addr));
 
-			if (memcmp(&server->addr,&peer->addr,sizeof(struct in_addr))==0)
+			if (memcmp(&server->addr, &peer->addr,
+				   sizeof(struct in_addr)) == 0)
 				goto found_dead_server;
 		}
 		spin_unlock(&cell->sv_gylock);
@@ -381,7 +379,7 @@
 	/* we found it in the graveyard - resurrect it */
  found_dead_server:
 	list_del(&server->link);
-	list_add_tail(&server->link,&cell->sv_list);
+	list_add_tail(&server->link, &cell->sv_list);
 	afs_get_server(server);
 	afs_kafstimod_del_timer(&server->timeout);
 	spin_unlock(&cell->sv_gylock);
@@ -396,7 +394,7 @@
 	read_unlock(&afs_cells_lock);
 
 	*_server = server;
-	_leave(" = 0 (s=%p c=%p)",server,cell);
+	_leave(" = 0 (s=%p c=%p)", server, cell);
 	return 0;
 
 } /* end afs_server_find_by_peer() */
@@ -408,8 +406,8 @@
  */
 void afs_cell_purge(void)
 {
-	afs_vlocation_t *vlocation;
-	afs_cell_t *cell;
+	struct afs_vlocation *vlocation;
+	struct afs_cell *cell;
 
 	_enter("");
 
@@ -422,17 +420,19 @@
 		write_lock(&afs_cells_lock);
 
 		if (!list_empty(&afs_cells)) {
-			cell = list_entry(afs_cells.next,afs_cell_t,link);
+			cell = list_entry(afs_cells.next,
+					  struct afs_cell, link);
 			list_del_init(&cell->link);
 		}
 
 		write_unlock(&afs_cells_lock);
 
 		if (cell) {
-			_debug("PURGING CELL %s (%d)",cell->name,atomic_read(&cell->usage));
+			_debug("PURGING CELL %s (%d)",
+			       cell->name, atomic_read(&cell->usage));
 
-			if (!list_empty(&cell->sv_list)) BUG();
-			if (!list_empty(&cell->vl_list)) BUG();
+			BUG_ON(!list_empty(&cell->sv_list));
+			BUG_ON(!list_empty(&cell->vl_list));
 
 			/* purge the cell's VL graveyard list */
 			_debug(" - clearing VL graveyard");
@@ -441,7 +441,8 @@
 
 			while (!list_empty(&cell->vl_graveyard)) {
 				vlocation = list_entry(cell->vl_graveyard.next,
-						       afs_vlocation_t,link);
+						       struct afs_vlocation,
+						       link);
 				list_del_init(&vlocation->link);
 
 				afs_kafstimod_del_timer(&vlocation->timeout);
@@ -449,7 +450,8 @@
 				spin_unlock(&cell->vl_gylock);
 
 				afs_vlocation_do_timeout(vlocation);
-				/* TODO: race if move to use krxtimod instead of kafstimod */
+				/* TODO: race if move to use krxtimod instead
+				 * of kafstimod */
 
 				spin_lock(&cell->vl_gylock);
 			}
@@ -462,9 +464,10 @@
 			spin_lock(&cell->sv_gylock);
 
 			while (!list_empty(&cell->sv_graveyard)) {
-				afs_server_t *server;
+				struct afs_server *server;
 
-				server = list_entry(cell->sv_graveyard.next,afs_server_t,link);
+				server = list_entry(cell->sv_graveyard.next,
+						    struct afs_server, link);
 				list_del_init(&server->link);
 
 				afs_kafstimod_del_timer(&server->timeout);
@@ -491,7 +494,8 @@
  * match a cell record obtained from the cache
  */
 #ifdef AFS_CACHING_SUPPORT
-static cachefs_match_val_t afs_cell_cache_match(void *target, const void *entry)
+static cachefs_match_val_t afs_cell_cache_match(void *target,
+						const void *entry)
 {
 	const struct afs_cache_cell *ccell = entry;
 	struct afs_cell *cell = target;

Index: callback.c
===================================================================
RCS file: /home/cvs/afs/fs/afs/callback.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- callback.c	10 Sep 2003 08:23:16 -0000	1.5
+++ callback.c	10 Sep 2003 13:32:37 -0000	1.6
@@ -24,28 +24,28 @@
 /*
  * allow the fileserver to request callback state (re-)initialisation
  */
-int SRXAFSCM_InitCallBackState(afs_server_t *server)
+int SRXAFSCM_InitCallBackState(struct afs_server *server)
 {
 	struct list_head callbacks;
 
-	_enter("%p",server);
+	_enter("%p", server);
 
 	INIT_LIST_HEAD(&callbacks);
 
 	/* transfer the callback list from the server to a temp holding area */
 	spin_lock(&server->cb_lock);
 
-	list_add(&callbacks,&server->cb_promises);
+	list_add(&callbacks, &server->cb_promises);
 	list_del_init(&server->cb_promises);
 
-	/* munch our way through the list, grabbing the inode, dropping all the locks and regetting
-	 * them in the right order
+	/* munch our way through the list, grabbing the inode, dropping all the
+	 * locks and regetting them in the right order
 	 */
 	while (!list_empty(&callbacks)) {
+		struct afs_vnode *vnode;
 		struct inode *inode;
-		afs_vnode_t *vnode;
 
-		vnode = list_entry(callbacks.next,afs_vnode_t,cb_link);
+		vnode = list_entry(callbacks.next, struct afs_vnode, cb_link);
 		list_del_init(&vnode->cb_link);
 
 		/* try and grab the inode - may fail */
@@ -56,7 +56,7 @@
 			spin_unlock(&server->cb_lock);
 			spin_lock(&vnode->lock);
 
-			if (vnode->cb_server==server) {
+			if (vnode->cb_server == server) {
 				vnode->cb_server = NULL;
 				afs_kafstimod_del_timer(&vnode->cb_timeout);
 				spin_lock(&afs_cb_hash_lock);
@@ -84,15 +84,14 @@
 /*
  * allow the fileserver to break callback promises
  */
-int SRXAFSCM_CallBack(afs_server_t *server, size_t count, afs_callback_t callbacks[])
+int SRXAFSCM_CallBack(struct afs_server *server, size_t count,
+		      struct afs_callback callbacks[])
 {
-	struct list_head *_p;
+	_enter("%p,%u,", server, count);
 
-	_enter("%p,%u,",server,count);
-
-	for (; count>0; callbacks++, count--) {
+	for (; count > 0; callbacks++, count--) {
+		struct afs_vnode *vnode = NULL;
 		struct inode *inode = NULL;
-		afs_vnode_t *vnode = NULL;
 		int valid = 0;
 
 		_debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
@@ -107,14 +106,15 @@
 		/* find the inode for this fid */
 		spin_lock(&afs_cb_hash_lock);
 
-		list_for_each(_p,&afs_cb_hash(server,&callbacks->fid)) {
-			vnode = list_entry(_p,afs_vnode_t,cb_hash_link);
-
-			if (memcmp(&vnode->fid,&callbacks->fid,sizeof(afs_fid_t))!=0)
+		list_for_each_entry(vnode,
+				    &afs_cb_hash(server, &callbacks->fid),
+				    cb_hash_link) {
+			if (memcmp(&vnode->fid, &callbacks->fid,
+				   sizeof(struct afs_fid)) != 0)
 				continue;
 
 			/* right vnode, but is it same server? */
-			if (vnode->cb_server!=server)
+			if (vnode->cb_server != server)
 				break; /* no */
 
 			/* try and nail the inode down */
@@ -127,7 +127,7 @@
 		if (inode) {
 			/* we've found the record for this vnode */
 			spin_lock(&vnode->lock);
-			if (vnode->cb_server==server) {
+			if (vnode->cb_server == server) {
 				/* the callback _is_ on the calling server */
 				vnode->cb_server = NULL;
 				valid = 1;
@@ -161,8 +161,8 @@
 /*
  * allow the fileserver to see if the cache manager is still alive
  */
-int SRXAFSCM_Probe(afs_server_t *server)
+int SRXAFSCM_Probe(struct afs_server *server)
 {
-	_debug("SRXAFSCM_Probe(%p)\n",server);
+	_debug("SRXAFSCM_Probe(%p)\n", server);
 	return 0;
 } /* end SRXAFSCM_Probe() */