jimzah/openafs
1
0
Fork 0
mirror of https://git.openafs.org/openafs.git synced 2025-01-20 16:00:12 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

death to register

Browse Source 
in soviet compilers, compiler optimizes you.
stop providing dated (and annoying for debugging) register keywords.

Change-Id: Ibcac0aa3f353fe531b9be0beedca919fb947bfab
Reviewed-on: http://gerrit.openafs.org/2436
Reviewed-by: Derrick Brashear <shadow@dementia.org>
Tested-by: Derrick Brashear <shadow@dementia.org>
This commit is contained in:
Marcus Watts 2010-07-14 23:13:20 -04:00 committed by Derrick Brashear
parent b44562f5dc
commit 4a531cb706
380 changed files with 3593 additions and 3597 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/afs/AIX/osi_config.c
View File

@ -211,14 +211,14 @@ kmem_free(p, size)
}
VN_RELE(vp)
register struct vnode *vp;
struct vnode *vp;
{
VNOP_RELE(vp);
}
VN_HOLD(vp)
register struct vnode *vp;
struct vnode *vp;
{
VNOP_HOLD(vp);
@ -293,14 +293,14 @@ struct k_var kvars[] = {
*/
kluge_init()
{
register struct k_func *kf;
register struct k_var *kv;
struct k_func *kf;
struct k_var *kv;
#ifdef __64BIT__
register afs_uint64 toc;
afs_uint64 toc;
#else
register afs_uint32 toc;
afs_uint32 toc;
#endif
register err = 0;
int err = 0;
toc = get_toc();
for (kf = kfuncs; !err && kf->name; ++kf) {

24
src/afs/AIX/osi_file.c
View File

@ -27,7 +27,7 @@ void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
struct osi_file *afile = NULL;
struct vnode *vp = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
@ -60,9 +60,9 @@ osi_UFSOpen(afs_dcache_id_t *ainode)
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
register afs_int32 code;
afs_int32 code;
struct vattr tvattr;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
@ -79,7 +79,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
@ -105,11 +105,11 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
afs_int32 mode = FWRITE | FSYNC;
AFS_STATCNT(osi_Truncate);
@ -147,13 +147,13 @@ osi_DisableAtimes(struct vnode *avp)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
unsigned int resid;
register afs_int32 code;
register afs_int32 cnt1 = 0;
afs_int32 code;
afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
@ -205,12 +205,12 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
unsigned int resid;
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
@ -254,7 +254,7 @@ afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
This routine written from the RT NFS port strategy routine.
It has been generalized a bit, but should still be pretty clear. */
int
afs_osi_MapStrategy(int (*aproc) (), register struct buf *bp)
afs_osi_MapStrategy(int (*aproc) (), struct buf *bp)
{
afs_int32 returnCode;

12
src/afs/AIX/osi_inode.c
View File

@ -165,7 +165,7 @@ igetinode(dev, vfsp, inode, vpp, perror)
int *perror;
{
struct inode *ip;
register was_locked;
int was_locked;
struct vfs *nvfsp = NULL;
int code;
*perror = 0;
@ -257,9 +257,9 @@ igetinode(dev, vfsp, inode, vpp, perror)
SYSENT(icreate, (dev, near_inode, param1, param2, param3, param4), (long dev, long near_inode, long param1, long param2, long param3, long param4))
{
struct inode *ip, *newip, *pip;
register int err, rval1, rc = 0;
int err, rval1, rc = 0;
struct vnode *vp = NULL;
register struct vfs *vfsp;
struct vfs *vfsp;
struct vfs *nvfsp = NULL;
char error;
ino_t ino = near_inode;
@ -320,10 +320,10 @@ SYSENT(icreate, (dev, near_inode, param1, param2, param3, param4), (long dev, lo
SYSENT(iopen, (dev, inode, usrmod),(int dev, int inode, int usrmod))
{
struct file *fp;
register struct inode *ip;
struct inode *ip;
struct vnode *vp = NULL;
extern struct fileops vnodefops;
register struct vfs *vfsp;
struct vfs *vfsp;
int fd;
char error;
struct ucred *credp;
@ -387,7 +387,7 @@ idec(dev, inode, inode_p1)
SYSENT(iincdec, (dev, inode, inode_p1, amount),(int dev, int inode, int inode_p1, int amount))
{
register struct inode *ip;
struct inode *ip;
char error;
struct vnode *vp = NULL;
int dummy;

8
src/afs/AIX/osi_misc.c
View File

@ -95,7 +95,7 @@ gop_rdwr(rw, vp, base, len, offset, segflg, unit, aresid)
{
struct uio uio_struct;
struct iovec uiovector;
register int code;
int code;
AFS_STATCNT(gop_rdwr);
/* Set up the uio structure */
@ -137,8 +137,8 @@ gop_rdwr(rw, vp, base, len, offset, segflg, unit, aresid)
aix_gnode_rele(vp)
struct vnode *vp;
{
register struct vnode *tvp;
register struct vfs *vfsp = vp->v_vfsp;
struct vnode *tvp;
struct vfs *vfsp = vp->v_vfsp;
/* Unlink the vnode from the list the vfs has hanging of it */
tvp = vfsp->vfs_vnodes;
@ -167,7 +167,7 @@ aix_gnode_rele(vp)
afs_suser(void *credp)
{
register rc;
int rc;
char err;
rc = suser(&err);

34
src/afs/AIX/osi_timeout.c
View File

@ -58,14 +58,14 @@ extern void tstart(struct trb *);
extern void i_enable(int);
void
timeout(register void (*func) (), /* function to call at timeout */
register caddr_t arg, /* It's argument. */
register int ticks, /* when to set timeout for */
register int type, register char *p1)
timeout(void (*func) (), /* function to call at timeout */
caddr_t arg, /* It's argument. */
int ticks, /* when to set timeout for */
int type, char *p1)
{
register int ipri; /* caller's interrupt priority */
register struct tos *tos; /* tos to use for timeout */
register struct trb *trb; /* trb in the tos being used */
int ipri; /* caller's interrupt priority */
struct tos *tos; /* tos to use for timeout */
struct trb *trb; /* trb in the tos being used */
struct itimerstruc_t tv; /* timeout interval */
tv.it_value.tv_sec = ticks / HZ;
@ -135,11 +135,11 @@ timeout(register void (*func) (), /* function to call at timeout */
void
untimeout(register void (*func) (), register ulong arg)
untimeout(void (*func) (), ulong arg)
{
register int ipri; /* caller's interrupt priority */
register struct tos *tos; /* tos to walk callout table */
register struct trb *trb; /* trb for this tos */
int ipri; /* caller's interrupt priority */
struct tos *tos; /* tos to walk callout table */
struct trb *trb; /* trb for this tos */
untimeout_retry:
@ -173,7 +173,7 @@ untimeout(register void (*func) (), register ulong arg)
static void
timeout_end(struct trb *trb)
{ /* trb of the current timeout */
register void (*func) (); /* function to call at timeout */
void (*func) (); /* function to call at timeout */
int ipri;
ipri = AFS_DISABLE_LOCK(INTMAX, &afs_callout_lock);
@ -189,12 +189,12 @@ timeout_end(struct trb *trb)
int
timeoutcf(register int cocnt)
timeoutcf(int cocnt)
{ /* # entries to change callout table by */
register int ipri; /* caller's interrupt priority */
register int rv; /* return value to the caller */
register struct tos *tos; /* tos to add to/remove from table */
register struct trb *trb; /* trb in the tos to be added/removed */
int ipri; /* caller's interrupt priority */
int rv; /* return value to the caller */
struct tos *tos; /* tos to add to/remove from table */
struct trb *trb; /* trb in the tos to be added/removed */
rv = 0;

6
src/afs/AIX/osi_vfsops.c
View File

@ -25,7 +25,7 @@
extern struct afs_exporter *afs_nfsexporter;
#endif
#define AFS_VFSLOCK_DECL register int glockOwner = ISAFS_GLOCK()
#define AFS_VFSLOCK_DECL int glockOwner = ISAFS_GLOCK()
#define AFS_VFSLOCK() if (!glockOwner) AFS_GLOCK()
#define AFS_VFSUNLOCK() if (!glockOwner) AFS_GUNLOCK()
@ -110,9 +110,9 @@ afs_unmount(struct vfs *afsp, int flag)
static int
afs_root_nolock(struct vfs *afsp, struct vnode **avpp)
{
register afs_int32 code = 0;
afs_int32 code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
AFS_STATCNT(afs_root);
if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {

20
src/afs/DARWIN/osi_file.c
View File

@ -135,7 +135,7 @@ osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct vnode *vp;
struct vattr va;
register struct osi_file *afile = NULL;
struct osi_file *afile = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
int dummy;
@ -193,9 +193,9 @@ osi_UFSOpen(afs_dcache_id_t *ainode)
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
register afs_int32 code;
afs_int32 code;
struct vattr tvattr;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
@ -223,7 +223,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
@ -239,11 +239,11 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
@ -300,12 +300,12 @@ osi_DisableAtimes(struct vnode *avp)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
afs_size_t resid;
register afs_int32 code;
afs_int32 code;
#ifdef AFS_DARWIN80_ENV
uio_t uio;
#endif
@ -351,12 +351,12 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
afs_size_t resid;
register afs_int32 code;
afs_int32 code;
#ifdef AFS_DARWIN80_ENV
uio_t uio;
#endif

12
src/afs/DARWIN/osi_inode.c
View File

@ -63,7 +63,7 @@ igetinode(vfsp, dev, inode, vpp, va, perror)
{
vnode_t pvp, vp;
extern struct osi_dev cacheDev;
register int code = 0;
int code = 0;
*perror = 0;
@ -116,12 +116,12 @@ getinode(fs, dev, inode, vpp, perror)
*vpp = 0;
*perror = 0;
if (!fs) {
register struct ufsmount *ump;
struct ufsmount *ump;
#ifdef VFSTOHFS
register struct hfsmount *hmp;
struct hfsmount *hmp;
#endif
register struct vnode *vp;
register struct mount *mp;
struct vnode *vp;
struct mount *mp;
extern struct mount *rootfs;
if (mp = rootfs)
do {
@ -174,7 +174,7 @@ igetinode(vfsp, dev, inode, vpp, va, perror)
{
struct vnode *pvp, *vp;
extern struct osi_dev cacheDev;
register int code = 0;
int code = 0;
*perror = 0;

2
src/afs/DARWIN/osi_vfsops.c
View File

@ -221,7 +221,7 @@ afs_root(struct mount *mp, struct vnode **vpp)
void *mdata = vfs_fsprivate(mp);
int error;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
#ifdef AFS_DARWIN80_ENV
struct ucred *cr = vfs_context_ucred(ctx);
int needref=0;

44
src/afs/DARWIN/osi_vnodeops.c
View File

@ -281,7 +281,7 @@ afs_vop_lookup(ap)
int error;
struct vcache *vcp;
struct vnode *vp, *dvp;
register int flags = ap->a_cnp->cn_flags;
int flags = ap->a_cnp->cn_flags;
int lockparent; /* 1 => lockparent flag is set */
int wantparent; /* 1 => wantparent or lockparent flag */
struct proc *p;
@ -402,7 +402,7 @@ afs_vop_create(ap)
{
int error = 0;
struct vcache *vcp;
register struct vnode *dvp = ap->a_dvp;
struct vnode *dvp = ap->a_dvp;
struct proc *p;
GETNAME();
p = vop_cn_proc;
@ -829,7 +829,7 @@ afs_vop_pagein(ap)
* int a_flags;
* } */ *ap;
{
register struct vnode *vp = ap->a_vp;
struct vnode *vp = ap->a_vp;
upl_t pl = ap->a_pl;
size_t size = ap->a_size;
off_t f_offset = ap->a_f_offset;
@ -974,7 +974,7 @@ afs_vop_pageout(ap)
* int a_flags
* } */ *ap;
{
register struct vnode *vp = ap->a_vp;
struct vnode *vp = ap->a_vp;
upl_t pl = ap->a_pl;
size_t size = ap->a_size;
off_t f_offset = ap->a_f_offset;
@ -1207,7 +1207,7 @@ afs_vop_fsync(ap)
{
int wait = ap->a_waitfor == MNT_WAIT;
int error;
register struct vnode *vp = ap->a_vp;
struct vnode *vp = ap->a_vp;
int haveGlock = ISAFS_GLOCK();
/* afs_vop_lookup glocks, can call us through vinvalbuf from GetVCache */
@ -1245,8 +1245,8 @@ afs_vop_remove(ap)
* } */ *ap;
{
int error = 0;
register struct vnode *vp = ap->a_vp;
register struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct vnode *dvp = ap->a_dvp;
#ifdef AFS_DARWIN80_ENV
if (ap->a_flags & VNODE_REMOVE_NODELETEBUSY) {
@ -1310,8 +1310,8 @@ afs_vop_link(ap)
* } */ *ap;
{
int error = 0;
register struct vnode *dvp = ap->a_tdvp;
register struct vnode *vp = ap->a_vp;
struct vnode *dvp = ap->a_tdvp;
struct vnode *vp = ap->a_vp;
struct proc *p;
GETNAME();
@ -1362,9 +1362,9 @@ afs_vop_rename(ap)
struct componentname *tcnp = ap->a_tcnp;
char *tname;
struct vnode *tvp = ap->a_tvp;
register struct vnode *tdvp = ap->a_tdvp;
struct vnode *tdvp = ap->a_tdvp;
struct vnode *fvp = ap->a_fvp;
register struct vnode *fdvp = ap->a_fdvp;
struct vnode *fdvp = ap->a_fdvp;
struct proc *p;
p = cn_proc(fcnp);
@ -1562,8 +1562,8 @@ afs_vop_mkdir(ap)
* struct vattr *a_vap;
* } */ *ap;
{
register struct vnode *dvp = ap->a_dvp;
register struct vattr *vap = ap->a_vap;
struct vnode *dvp = ap->a_dvp;
struct vattr *vap = ap->a_vap;
int error = 0;
struct vcache *vcp;
struct proc *p;
@ -1613,8 +1613,8 @@ afs_vop_rmdir(ap)
* } */ *ap;
{
int error = 0;
register struct vnode *vp = ap->a_vp;
register struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct vnode *dvp = ap->a_dvp;
GETNAME();
if (dvp == vp) {
@ -1650,7 +1650,7 @@ afs_vop_symlink(ap)
* char *a_target;
* } */ *ap;
{
register struct vnode *dvp = ap->a_dvp;
struct vnode *dvp = ap->a_dvp;
int error = 0;
/* NFS ignores a_vpp; so do we. */
@ -1750,7 +1750,7 @@ afs_vop_inactive(ap)
* struct proc *a_p;
* } */ *ap;
{
register struct vnode *vp = ap->a_vp;
struct vnode *vp = ap->a_vp;
struct vcache *tvc = VTOAFS(vp);
#ifndef AFS_DARWIN80_ENV
if (prtactive && vp->v_usecount != 0)
@ -1784,7 +1784,7 @@ afs_vop_reclaim(ap)
{
int error = 0;
int sl, writelocked;
register struct vnode *vp = ap->a_vp;
struct vnode *vp = ap->a_vp;
struct vcache *tvc = VTOAFS(vp);
osi_Assert(!ISAFS_GLOCK());
@ -1959,8 +1959,8 @@ afs_vop_lock(ap)
* struct vnode *a_vp;
* } */ *ap;
{
register struct vnode *vp = ap->a_vp;
register struct vcache *avc = VTOAFS(vp);
struct vnode *vp = ap->a_vp;
struct vcache *avc = VTOAFS(vp);
if (vp->v_tag == VT_NON)
return (ENOENT);
@ -2057,8 +2057,8 @@ afs_vop_print(ap)
* struct vnode *a_vp;
* } */ *ap;
{
register struct vnode *vp = ap->a_vp;
register struct vcache *vc = VTOAFS(ap->a_vp);
struct vnode *vp = ap->a_vp;
struct vcache *vc = VTOAFS(ap->a_vp);
int s = vc->f.states;
printf("tag %d, fid: %ld.%x.%x.%x, opens %d, writers %d", vp->v_tag,
vc->f.fid.Cell, vc->f.fid.Fid.Volume, vc->f.fid.Fid.Vnode,

20
src/afs/FBSD/osi_file.c
View File

@ -59,9 +59,9 @@ osi_UFSOpen(afs_dcache_id_t *ainode)
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
register afs_int32 code;
afs_int32 code;
struct vattr tvattr;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
@ -86,7 +86,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
@ -98,11 +98,11 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
struct vattr tvattr;
struct vnode *vp;
register afs_int32 code, glocked;
afs_int32 code, glocked;
AFS_STATCNT(osi_Truncate);
ObtainWriteLock(&afs_xosi, 321);
@ -155,11 +155,11 @@ osi_DisableAtimes(struct vnode *avp)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
unsigned int resid;
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(osi_Read);
/**
@ -194,11 +194,11 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
unsigned int resid;
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
@ -229,7 +229,7 @@ afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
This routine written from the RT NFS port strategy routine.
It has been generalized a bit, but should still be pretty clear. */
int
afs_osi_MapStrategy(int (*aproc) (), register struct buf *bp)
afs_osi_MapStrategy(int (*aproc) (), struct buf *bp)
{
afs_int32 returnCode;

12
src/afs/FBSD/osi_inode.c
View File

@ -45,8 +45,8 @@ getinode(fs, dev, inode, ipp, perror)
*ipp = 0;
*perror = 0;
if (!fs) {
register struct ufsmount *ump;
register struct mount *mp;
struct ufsmount *ump;
struct mount *mp;
mtx_lock(&mountlist_mtx);
if ((mp = TAILQ_FIRST(&mountlist)) != NULL)
@ -93,7 +93,7 @@ igetinode(vfsp, dev, inode, ipp, perror)
int *perror;
{
struct inode *ip;
register int code = 0;
int code = 0;
*perror = 0;
@ -128,7 +128,7 @@ afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
{
int dummy, err = 0;
struct inode *ip, *newip;
register int code;
int code;
struct vnode *vp;
AFS_STATCNT(afs_syscall_icreate);
@ -207,7 +207,7 @@ afs_syscall_iopen(dev, inode, usrmod, retval)
int dummy;
int fd;
extern struct fileops vnops;
register int code;
int code;
AFS_STATCNT(afs_syscall_iopen);
@ -248,7 +248,7 @@ afs_syscall_iincdec(dev, inode, inode_p1, amount)
{
int dummy;
struct inode *ip;
register int code;
int code;
if (!afs_suser(NULL))
return (EPERM);

2
src/afs/FBSD/osi_vfsops.c
View File

@ -195,7 +195,7 @@ afs_root(struct mount *mp, struct vnode **vpp)
{
int error;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
#if !defined(AFS_FBSD53_ENV) || defined(AFS_FBSD80_ENV)
struct thread *td = curthread;
#endif

30
src/afs/FBSD/osi_vnodeops.c
View File

@ -478,7 +478,7 @@ afs_vop_lookup(ap)
int error;
struct vcache *vcp;
struct vnode *vp, *dvp;
register int flags = ap->a_cnp->cn_flags;
int flags = ap->a_cnp->cn_flags;
int lockparent; /* 1 => lockparent flag is set */
int wantparent; /* 1 => wantparent or lockparent flag */
struct thread *p = ap->a_cnp->cn_thread;
@ -572,7 +572,7 @@ afs_vop_create(ap)
{
int error = 0;
struct vcache *vcp;
register struct vnode *dvp = ap->a_dvp;
struct vnode *dvp = ap->a_dvp;
struct thread *p = ap->a_cnp->cn_thread;
GETNAME();
@ -1085,7 +1085,7 @@ afs_vop_fsync(ap)
* } */ *ap;
{
int error;
register struct vnode *vp = ap->a_vp;
struct vnode *vp = ap->a_vp;
AFS_GLOCK();
/*vflushbuf(vp, wait); */
@ -1110,8 +1110,8 @@ afs_vop_remove(ap)
* } */ *ap;
{
int error = 0;
register struct vnode *vp = ap->a_vp;
register struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct vnode *dvp = ap->a_dvp;
GETNAME();
AFS_GLOCK();
@ -1131,8 +1131,8 @@ afs_vop_link(ap)
* } */ *ap;
{
int error = 0;
register struct vnode *dvp = ap->a_tdvp;
register struct vnode *vp = ap->a_vp;
struct vnode *dvp = ap->a_tdvp;
struct vnode *vp = ap->a_vp;
struct thread *p = ap->a_cnp->cn_thread;
GETNAME();
@ -1174,9 +1174,9 @@ afs_vop_rename(ap)
struct componentname *tcnp = ap->a_tcnp;
char *tname;
struct vnode *tvp = ap->a_tvp;
register struct vnode *tdvp = ap->a_tdvp;
struct vnode *tdvp = ap->a_tdvp;
struct vnode *fvp = ap->a_fvp;
register struct vnode *fdvp = ap->a_fdvp;
struct vnode *fdvp = ap->a_fdvp;
struct thread *p = fcnp->cn_thread;
/*
@ -1275,8 +1275,8 @@ afs_vop_mkdir(ap)
* struct vattr *a_vap;
* } */ *ap;
{
register struct vnode *dvp = ap->a_dvp;
register struct vattr *vap = ap->a_vap;
struct vnode *dvp = ap->a_dvp;
struct vattr *vap = ap->a_vap;
int error = 0;
struct vcache *vcp;
struct thread *p = ap->a_cnp->cn_thread;
@ -1311,7 +1311,7 @@ afs_vop_rmdir(ap)
* } */ *ap;
{
int error = 0;
register struct vnode *dvp = ap->a_dvp;
struct vnode *dvp = ap->a_dvp;
GETNAME();
AFS_GLOCK();
@ -1433,7 +1433,7 @@ afs_vop_inactive(ap)
* struct thread *td;
* } */ *ap;
{
register struct vnode *vp = ap->a_vp;
struct vnode *vp = ap->a_vp;
if (prtactive && vp->v_usecount != 0)
vprint("afs_vop_inactive(): pushing active", vp);
@ -1535,8 +1535,8 @@ afs_vop_print(ap)
* struct vnode *a_vp;
* } */ *ap;
{
register struct vnode *vp = ap->a_vp;
register struct vcache *vc = VTOAFS(ap->a_vp);
struct vnode *vp = ap->a_vp;
struct vcache *vc = VTOAFS(ap->a_vp);
int s = vc->f.states;
printf("tag %s, fid: %d.%d.%d.%d, opens %d, writers %d", vp->v_tag,

22
src/afs/HPUX/osi_file.c
View File

@ -28,7 +28,7 @@ void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
struct osi_file *afile = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
int dummy;
@ -61,9 +61,9 @@ osi_UFSOpen(afs_dcache_id_t *ainode)
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
register afs_int32 code;
afs_int32 code;
struct vattr tvattr;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
@ -80,7 +80,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
@ -92,11 +92,11 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
@ -133,13 +133,13 @@ osi_DisableAtimes(struct vnode *avp)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
long resid;
register afs_int32 code;
register afs_int32 cnt1 = 0;
afs_int32 code;
afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
@ -184,12 +184,12 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
long resid;
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");

2
src/afs/HPUX/osi_gcpags.c
View File

@ -36,7 +36,7 @@
void
afs_osi_TraverseProcTable(void)
{
register proc_t *p;
proc_t *p;
int endchain = 0;
MP_SPINLOCK(activeproc_lock);

2
src/afs/HPUX/osi_groups.c
View File

@ -122,7 +122,7 @@ afs_setgroups(struct ucred **cred, int ngroups, gid_t * gidset,
struct ucred *newcr;
ulong_t s;
#if defined(AFS_HPUX110_ENV)
register ulong_t context;
ulong_t context;
#endif
AFS_STATCNT(afs_setgroups);

6
src/afs/HPUX/osi_inode.c
View File

@ -46,7 +46,7 @@ igetinode(struct vfs *vfsp, dev_t dev, ino_t inode, int *perror)
{
struct inode *pip, *ip;
extern struct osi_dev cacheDev;
register int code = 0;
int code = 0;
*perror = 0;
AFS_STATCNT(igetinode);
@ -125,7 +125,7 @@ afs_syscall_iopen(dev, inode, usrmod)
struct vnode *vp = NULL;
int dummy;
extern struct fileops vnodefops;
register int code;
int code;
int fd;
AFS_STATCNT(afs_syscall_iopen);
@ -187,7 +187,7 @@ afs_syscall_iincdec(dev, inode, inode_p1, amount)
{
int dummy;
struct inode *ip;
register afs_int32 code;
afs_int32 code;
if (!afs_suser(NULL)) {
u.u_error = EPERM;

2
src/afs/HPUX/osi_machdep.h
View File

@ -81,7 +81,7 @@ extern void afsHashRelease(tid_t key);
#endif
/* Uses splnet only in the SP case */
#define SPLVAR register ulong_t splvar
#define SPLVAR ulong_t splvar
#define NETPRI NET_SPLNET(splvar)
#define USERPRI NET_SPLX(splvar)

8
src/afs/HPUX/osi_sleep.c
View File

@ -22,8 +22,8 @@ static char waitV;
/* call procedure aproc with arock as an argument, in ams milliseconds */
static int
afs_osi_CallProc(aproc, arock, ams)
register void (*aproc) ();
register char *arock;
void (*aproc) ();
char *arock;
afs_int32 ams;
{
int code;
@ -43,8 +43,8 @@ afs_osi_CallProc(aproc, arock, ams)
/* cancel a timeout, whether or not it has already occurred */
static int
afs_osi_CancelProc(aproc, arock)
register void (*aproc) ();
register char *arock;
void (*aproc) ();
char *arock;
{
int code = 0;
AFS_STATCNT(osi_CancelProc);

6
src/afs/HPUX/osi_vfsops.c
View File

@ -114,7 +114,7 @@ afs_root(struct vfs *afsp, struct vnode **avpp, char *unused1)
{
int code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
AFS_GLOCK();
AFS_STATCNT(afs_root);
@ -152,7 +152,7 @@ afs_root(struct vfs *afsp, struct vnode **avpp, char *unused1)
}
int
afs_statfs(register struct vfs *afsp, struct k_statvfs *abp)
afs_statfs(struct vfs *afsp, struct k_statvfs *abp)
{
AFS_GLOCK();
AFS_STATCNT(afs_statfs);
@ -251,7 +251,7 @@ b_sema_t afs_global_sema = { 0 };
void
osi_InitGlock()
{
register ulong_t context;
ulong_t context;
SPINLOCK_USAV(sched_lock, context);
if (!afs_Starting) {

114
src/afs/HPUX/osi_vnodeops.c
View File

@ -69,11 +69,11 @@ extern int afs_close();
*/
int
m_cpytoc(m, off, len, cp)
register struct mbuf *m;
register int off, len;
register caddr_t cp;
struct mbuf *m;
int off, len;
caddr_t cp;
{
register int ml;
int ml;
if (m == NULL || off < 0 || len < 0 || cp == NULL)
osi_Panic("m_cpytoc");
@ -275,7 +275,7 @@ afs_brelse(vp, bp)
afs_bmap(avc, abn, anvp, anbn)
register struct vcache *avc;
struct vcache *avc;
kern_daddr_t abn, *anbn;
struct vcache **anvp;
{
@ -288,7 +288,7 @@ afs_bmap(avc, abn, anvp, anbn)
}
afs_inactive(avc, acred)
register struct vcache *avc;
struct vcache *avc;
afs_ucred_t *acred;
{
struct vnode *vp = AFSTOV(avc);
@ -320,9 +320,9 @@ afs_inactive(avc, acred)
int
mp_afs_open(register struct vnode **avcp, int aflags, afs_ucred_t *acred)
mp_afs_open(struct vnode **avcp, int aflags, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_open(avcp, aflags, acred);
@ -331,9 +331,9 @@ mp_afs_open(register struct vnode **avcp, int aflags, afs_ucred_t *acred)
}
int
mp_afs_close(register struct vnode *avcp, int aflags, afs_ucred_t *acred)
mp_afs_close(struct vnode *avcp, int aflags, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_close(avcp, aflags, acred);
@ -342,10 +342,10 @@ mp_afs_close(register struct vnode *avcp, int aflags, afs_ucred_t *acred)
}
int
mp_afs_rdwr(register struct vnode *avcp, struct uio *uio, enum uio_rw arw,
mp_afs_rdwr(struct vnode *avcp, struct uio *uio, enum uio_rw arw,
int aio, afs_ucred_t *acred)
{
register int code;
int code;
long save_resid;
AFS_GLOCK();
@ -360,10 +360,10 @@ mp_afs_rdwr(register struct vnode *avcp, struct uio *uio, enum uio_rw arw,
}
int
mp_afs_getattr(register struct vnode *avcp, struct vattr *attrs,
mp_afs_getattr(struct vnode *avcp, struct vattr *attrs,
afs_ucred_t *acred, enum vsync unused1)
{
register int code;
int code;
AFS_GLOCK();
code = afs_getattr(avcp, attrs, acred);
@ -372,10 +372,10 @@ mp_afs_getattr(register struct vnode *avcp, struct vattr *attrs,
}
int
mp_afs_setattr(register struct vnode *avcp, register struct vattr *attrs,
mp_afs_setattr(struct vnode *avcp, struct vattr *attrs,
afs_ucred_t *acred, int unused1)
{
register int code;
int code;
AFS_GLOCK();
code = afs_setattr(avcp, attrs, acred);
@ -384,9 +384,9 @@ mp_afs_setattr(register struct vnode *avcp, register struct vattr *attrs,
}
int
mp_afs_access(register struct vnode *avcp, int mode, afs_ucred_t *acred)
mp_afs_access(struct vnode *avcp, int mode, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_access(avcp, mode, acred);
@ -395,11 +395,11 @@ mp_afs_access(register struct vnode *avcp, int mode, afs_ucred_t *acred)
}
int
mp_afs_lookup(register struct vnode *adp, char *aname,
register struct vnode **avcp, afs_ucred_t *acred,
mp_afs_lookup(struct vnode *adp, char *aname,
struct vnode **avcp, afs_ucred_t *acred,
struct vnode *unused1)
{
register int code;
int code;
AFS_GLOCK();
code = afs_lookup(adp, aname, avcp, acred);
@ -408,11 +408,11 @@ mp_afs_lookup(register struct vnode *adp, char *aname,
}
int
mp_afs_create(register struct vnode *adp, char *aname, struct vattr *attrs,
mp_afs_create(struct vnode *adp, char *aname, struct vattr *attrs,
enum vcexcl aexcl, int amode, struct vnode **avcp,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_create(adp, aname, attrs, aexcl, amode, avcp, acred);
@ -422,10 +422,10 @@ mp_afs_create(register struct vnode *adp, char *aname, struct vattr *attrs,
int
mp_afs_remove(register struct vnode *adp, char *aname,
mp_afs_remove(struct vnode *adp, char *aname,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_remove(adp, aname, acred);
@ -434,10 +434,10 @@ mp_afs_remove(register struct vnode *adp, char *aname,
}
int
mp_afs_link(register struct vnode *avc, register struct vnode *adp,
mp_afs_link(struct vnode *avc, struct vnode *adp,
char *aname, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_link(avc, adp, aname, acred);
@ -446,11 +446,11 @@ mp_afs_link(register struct vnode *avc, register struct vnode *adp,
}
int
mp_afs_rename(register struct vnode *aodp, char *aname1,
register struct vnode *andp, char *aname2,
mp_afs_rename(struct vnode *aodp, char *aname1,
struct vnode *andp, char *aname2,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_rename(aodp, aname1, andp, aname2, acred);
@ -459,10 +459,10 @@ mp_afs_rename(register struct vnode *aodp, char *aname1,
}
int
mp_afs_mkdir(register struct vnode *adp, char *aname, struct vattr *attrs,
register struct vnode **avcp, afs_ucred_t *acred)
mp_afs_mkdir(struct vnode *adp, char *aname, struct vattr *attrs,
struct vnode **avcp, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_mkdir(adp, aname, attrs, avcp, acred);
@ -472,9 +472,9 @@ mp_afs_mkdir(register struct vnode *adp, char *aname, struct vattr *attrs,
int
mp_afs_rmdir(register struct vnode *adp, char *aname, afs_ucred_t *acred)
mp_afs_rmdir(struct vnode *adp, char *aname, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_rmdir(adp, aname, acred);
@ -484,10 +484,10 @@ mp_afs_rmdir(register struct vnode *adp, char *aname, afs_ucred_t *acred)
int
mp_afs_readdir(register struct vnode *avc, struct uio *auio,
mp_afs_readdir(struct vnode *avc, struct uio *auio,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_readdir(avc, auio, acred);
@ -496,10 +496,10 @@ mp_afs_readdir(register struct vnode *avc, struct uio *auio,
}
int
mp_afs_symlink(register struct vnode *adp, char *aname, struct vattr *attrs,
mp_afs_symlink(struct vnode *adp, char *aname, struct vattr *attrs,
char *atargetName, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_symlink(adp, aname, attrs, atargetName, acred);
@ -509,10 +509,10 @@ mp_afs_symlink(register struct vnode *adp, char *aname, struct vattr *attrs,
int
mp_afs_readlink(register struct vnode *avc, struct uio *auio,
mp_afs_readlink(struct vnode *avc, struct uio *auio,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_readlink(avc, auio, acred);
@ -521,9 +521,9 @@ mp_afs_readlink(register struct vnode *avc, struct uio *auio,
}
int
mp_afs_fsync(register struct vnode *avc, afs_ucred_t *acred, int unused1)
mp_afs_fsync(struct vnode *avc, afs_ucred_t *acred, int unused1)
{
register int code;
int code;
AFS_GLOCK();
code = afs_fsync(avc, acred);
@ -532,10 +532,10 @@ mp_afs_fsync(register struct vnode *avc, afs_ucred_t *acred, int unused1)
}
int
mp_afs_bread(register struct vnode *avc, kern_daddr_t lbn, struct buf **bpp,
mp_afs_bread(struct vnode *avc, kern_daddr_t lbn, struct buf **bpp,
struct vattr *unused1, struct ucred *unused2)
{
register int code;
int code;
AFS_GLOCK();
code = afs_bread(avc, lbn, bpp);
@ -544,9 +544,9 @@ mp_afs_bread(register struct vnode *avc, kern_daddr_t lbn, struct buf **bpp,
}
int
mp_afs_brelse(register struct vnode *avc, struct buf *bp)
mp_afs_brelse(struct vnode *avc, struct buf *bp)
{
register int code;
int code;
AFS_GLOCK();
code = afs_brelse(avc, bp);
@ -556,9 +556,9 @@ mp_afs_brelse(register struct vnode *avc, struct buf *bp)
int
mp_afs_inactive(register struct vnode *avc, afs_ucred_t *acred)
mp_afs_inactive(struct vnode *avc, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_inactive(avc, acred);
@ -571,7 +571,7 @@ mp_afs_lockctl(struct vnode *avc, struct flock *af, int cmd,
afs_ucred_t *acred, struct file *unused1, off_t unused2,
off_t unused3)
{
register int code;
int code;
AFS_GLOCK();
code = afs_lockctl(avc, af, cmd, acred);
@ -582,7 +582,7 @@ mp_afs_lockctl(struct vnode *avc, struct flock *af, int cmd,
int
mp_afs_fid(struct vnode *avc, struct fid **fidpp)
{
register int code;
int code;
AFS_GLOCK();
code = afs_fid(avc, fidpp);
@ -591,10 +591,10 @@ mp_afs_fid(struct vnode *avc, struct fid **fidpp)
}
int
mp_afs_readdir2(register struct vnode *avc, struct uio *auio,
mp_afs_readdir2(struct vnode *avc, struct uio *auio,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_readdir2(avc, auio, acred);
@ -1566,7 +1566,7 @@ afs_pageout(vp, prp, start, end, flags)
* if pageiodone() will not be called automatically.
*/
if (!(bp->b_flags & B_CALL) && steal) {
register ulong_t context;
ulong_t context;
SPINLOCK_USAV(pfdat_lock, context);
parolemem += btorp(nbytes);
@ -2513,13 +2513,13 @@ afsHashGarbageCollect()
afs_hp_strategy(bp)
register struct buf *bp;
struct buf *bp;
{
register afs_int32 code;
afs_int32 code;
struct uio tuio;
struct iovec tiovec[1];
extern caddr_t hdl_kmap_bp();
register struct kthread *t = u.u_kthreadp;
struct kthread *t = u.u_kthreadp;
AFS_STATCNT(afs_hp_strategy);
/*

24
src/afs/IRIX/osi_file.c
View File

@ -41,7 +41,7 @@ void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
struct osi_file *afile = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
int dummy;
@ -66,9 +66,9 @@ osi_UFSOpen(afs_dcache_id_t *ainode)
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
register afs_int32 code;
afs_int32 code;
struct vattr tvattr;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
@ -86,7 +86,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
@ -98,11 +98,11 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
mon_state_t ms;
AFS_STATCNT(osi_Truncate);
@ -127,13 +127,13 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
ssize_t resid;
register afs_int32 code;
register afs_int32 cnt1 = 0;
afs_int32 code;
afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
@ -167,12 +167,12 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
ssize_t resid;
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
@ -204,7 +204,7 @@ afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
This routine written from the RT NFS port strategy routine.
It has been generalized a bit, but should still be pretty clear. */
int
afs_osi_MapStrategy(int (*aproc) (), register struct buf *bp)
afs_osi_MapStrategy(int (*aproc) (), struct buf *bp)
{
afs_int32 returnCode;

6
src/afs/IRIX/osi_idbg.c
View File

@ -24,9 +24,9 @@
* debugging routine - invoked by calling kp vnode xx
*/
static void
printflags(register unsigned int flags, register char **strings)
printflags(unsigned int flags, char **strings)
{
register int mask = 1;
int mask = 1;
while (flags != 0) {
if (mask & flags) {
@ -104,7 +104,7 @@ int
idbg_afsvfslist()
{
struct vcache *tvc;
register struct afs_q *tq;
struct afs_q *tq;
struct afs_q *uq;
afs_int32 nodeid; /* what ls prints as 'inode' */

6
src/afs/IRIX/osi_machdep.h
View File

@ -68,7 +68,7 @@ extern flid_t osi_flid;
#undef AFS_MUTEX_ENTER
#define AFS_MUTEX_ENTER(mp) \
MACRO_BEGIN \
register struct kthread *_kthreadP; \
struct kthread *_kthreadP; \
while(mutex_tryenter(mp) == 0) { \
_kthreadP = (struct kthread*)mutex_owner(mp); \
if (_kthreadP != NULL && _kthreadP->k_sonproc == CPU_NONE) { \
@ -112,7 +112,7 @@ extern flid_t osi_flid;
#define AFS_MUTEX_ENTER(mp) \
MACRO_BEGIN \
register struct proc *_procP; \
struct proc *_procP; \
while(mutex_tryenter(mp) == 0) { \
_procP = mutex_owner(mp); \
if (_procP != NULL && _procP->p_sonproc == CPU_NONE) { \
@ -183,7 +183,7 @@ extern long afs_global_owner;
#define AFS_GUNLOCK()
#define ISAFS_GLOCK() 1
#define SPLVAR register int splvar
#define SPLVAR int splvar
#define NETPRI splvar=splnet()
#define USERPRI splx(splvar)

12
src/afs/IRIX/osi_vfsops.c
View File

@ -201,7 +201,7 @@ afs_unmount(OSI_VFS_ARG(afsp), flags, cr)
{
struct vcache *tvc;
vnode_t *vp, *rootvp = NULL;
register struct afs_q *tq;
struct afs_q *tq;
struct afs_q *uq;
int error, fv_slept;
OSI_VFS_CONVERT(afsp);
@ -260,9 +260,9 @@ afs_root(OSI_VFS_ARG(afsp), avpp)
OSI_VFS_DECL(afsp);
struct vnode **avpp;
{
register afs_int32 code = 0;
afs_int32 code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
OSI_VFS_CONVERT(afsp);
AFS_STATCNT(afs_root);
@ -367,7 +367,7 @@ afs_sync(OSI_VFS_DECL(afsp),
struct vcache *tvc;
struct vnode *vp;
afs_uint32 lvcachegen;
register struct afs_q *tq;
struct afs_q *tq;
struct afs_q *uq;
int s;
OSI_VFS_CONVERT(afsp);
@ -511,8 +511,8 @@ afs_vget(OSI_VFS_DECL(afsp), vnode_t ** avcp, struct fid * fidp)
{
struct VenusFid vfid;
struct vrequest treq;
register struct cell *tcell;
register afs_int32 code = 0;
struct cell *tcell;
afs_int32 code = 0;
afs_int32 ret;
#if defined(AFS_SGI64_ENV) && defined(CKPT) && !defined(_R5000_CVT_WAR)

8
src/afs/IRIX/osi_vnodeops.c
View File

@ -52,7 +52,7 @@ extern void afs_rwunlock(OSI_VN_DECL(vp), AFS_RWLOCK_T b);
extern int afs_fid2();
static int afsrwvp(register struct vcache *avc, register struct uio *uio,
static int afsrwvp(struct vcache *avc, struct uio *uio,
enum uio_rw rw, int ioflag,
#ifdef AFS_SGI64_ENV
struct cred *cr, struct flid *flp);
@ -341,7 +341,7 @@ static int acchk = 0;
static int acdrop = 0;
static int
afsrwvp(register struct vcache *avc, register struct uio *uio, enum uio_rw rw,
afsrwvp(struct vcache *avc, struct uio *uio, enum uio_rw rw,
int ioflag,
#ifdef AFS_SGI64_ENV
struct cred *cr, struct flid *flp)
@ -349,7 +349,7 @@ afsrwvp(register struct vcache *avc, register struct uio *uio, enum uio_rw rw,
struct cred *cr)
#endif
{
register struct vnode *vp = AFSTOV(avc);
struct vnode *vp = AFSTOV(avc);
struct buf *bp;
daddr_t bn;
off_t acnt, cnt;
@ -927,7 +927,7 @@ OSI_VC_DECL(avc);
{
OSI_VC_CONVERT(avc);
struct vnode *vp = AFSTOV(avc);
register struct brequest *tb;
struct brequest *tb;
struct vrequest treq;
afs_int32 code;

14
src/afs/LINUX/osi_file.c
View File

@ -129,7 +129,7 @@ void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode) {
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
@ -142,7 +142,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile) {
@ -156,9 +156,9 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
struct iattr newattrs;
struct inode *inode = OSIFILE_INODE(afile);
@ -200,7 +200,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
struct uio auio;
@ -239,7 +239,7 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
struct uio auio;
@ -282,7 +282,7 @@ afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
This routine written from the RT NFS port strategy routine.
It has been generalized a bit, but should still be pretty clear. */
int
afs_osi_MapStrategy(int (*aproc) (struct buf * bp), register struct buf *bp)
afs_osi_MapStrategy(int (*aproc) (struct buf * bp), struct buf *bp)
{
afs_int32 returnCode;

4
src/afs/LINUX/osi_vfsops.c
View File

@ -152,9 +152,9 @@ afs_fill_super(struct super_block *sb, void *data, int silent)
static int
afs_root(struct super_block *afsp)
{
register afs_int32 code = 0;
afs_int32 code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
AFS_STATCNT(afs_root);
if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {

2
src/afs/LINUX/osi_vnodeops.c
View File

@ -186,7 +186,7 @@ afs_linux_readdir(struct file *fp, void *dirbuf, filldir_t filldir)
{
struct vcache *avc = VTOAFS(FILE_INODE(fp));
struct vrequest treq;
register struct dcache *tdc;
struct dcache *tdc;
int code;
int offset;
int dirpos;

18
src/afs/LINUX24/osi_file.c
View File

@ -29,7 +29,7 @@ extern struct super_block *afs_cacheSBp;
void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
register struct osi_file *afile = NULL;
struct osi_file *afile = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
struct inode *tip = NULL;
@ -81,9 +81,9 @@ void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode) {
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
astat->size = i_size_read(OSIFILE_INODE(afile));
@ -95,7 +95,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile) {
@ -112,9 +112,9 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
struct iattr newattrs;
struct inode *inode = OSIFILE_INODE(afile);
@ -183,7 +183,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
struct uio auio;
@ -222,7 +222,7 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
struct uio auio;
@ -265,7 +265,7 @@ afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
This routine written from the RT NFS port strategy routine.
It has been generalized a bit, but should still be pretty clear. */
int
afs_osi_MapStrategy(int (*aproc) (struct buf * bp), register struct buf *bp)
afs_osi_MapStrategy(int (*aproc) (struct buf * bp), struct buf *bp)
{
afs_int32 returnCode;

4
src/afs/LINUX24/osi_vfsops.c
View File

@ -130,9 +130,9 @@ afs_read_super(struct super_block *sb, void *data, int silent)
static int
afs_root(struct super_block *afsp)
{
register afs_int32 code = 0;
afs_int32 code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
AFS_STATCNT(afs_root);
if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {

2
src/afs/LINUX24/osi_vnodeops.c
View File

@ -221,7 +221,7 @@ afs_linux_readdir(struct file *fp, void *dirbuf, filldir_t filldir)
{
struct vcache *avc = VTOAFS(FILE_INODE(fp));
struct vrequest treq;
register struct dcache *tdc;
struct dcache *tdc;
int code;
int offset;
int dirpos;

2
src/afs/OBSD/osi_vfsops.c
View File

@ -216,7 +216,7 @@ afs_start(mp, flags, p)
int
afs_mount(mp, path, data, ndp, p)
register struct mount *mp;
struct mount *mp;
char *path;
caddr_t data;
struct nameidata *ndp;

26
src/afs/SOLARIS/osi_file.c
View File

@ -145,7 +145,7 @@ void *
osi_VxfsOpen(afs_dcache_id_t *ainode)
{
struct vnode *vp;
register struct osi_file *afile = NULL;
struct osi_file *afile = NULL;
afs_int32 code = 0;
int dummy;
afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
@ -172,7 +172,7 @@ osi_UfsOpen(afs_dcache_id_t *ainode)
#else
struct inode *ip;
#endif
register struct osi_file *afile = NULL;
struct osi_file *afile = NULL;
afs_int32 code = 0;
int dummy;
#ifdef AFS_CACHE_VNODE_PATH
@ -260,9 +260,9 @@ osi_UFSOpen(afs_dcache_id_t *ainode)
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
{
register afs_int32 code;
afs_int32 code;
struct vattr tvattr;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
@ -285,7 +285,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
}
int
osi_UFSClose(register struct osi_file *afile)
osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
@ -297,11 +297,11 @@ osi_UFSClose(register struct osi_file *afile)
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
@ -351,7 +351,7 @@ osi_DisableAtimes(struct vnode *avp)
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
@ -360,8 +360,8 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
#else
int resid;
#endif
register afs_int32 code;
register afs_int32 cnt1 = 0;
afs_int32 code;
afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
@ -396,7 +396,7 @@ afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
@ -405,7 +405,7 @@ afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
#else
int resid;
#endif
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
@ -434,7 +434,7 @@ afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
This routine written from the RT NFS port strategy routine.
It has been generalized a bit, but should still be pretty clear. */
int
afs_osi_MapStrategy(int (*aproc) (), register struct buf *bp)
afs_osi_MapStrategy(int (*aproc) (), struct buf *bp)
{
afs_int32 returnCode;

10
src/afs/SOLARIS/osi_inode.c
View File

@ -43,7 +43,7 @@ getinode(vfsp, dev, inode, ipp, credp, perror)
int *perror;
{
struct inode *ip;
register afs_int32 code;
afs_int32 code;
struct vnode *vp;
struct fs *fs;
struct inode *pip;
@ -91,7 +91,7 @@ igetinode(vfsp, dev, inode, ipp, credp, perror)
{
struct inode *pip, *ip;
extern struct osi_dev cacheDev;
register int code = 0;
int code = 0;
*perror = 0;
@ -150,7 +150,7 @@ afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, rvp,
{
int dummy, err = 0;
struct inode *ip, *newip;
register int code;
int code;
dev_t newdev;
struct ufsvfs *ufsvfsp;
@ -247,7 +247,7 @@ afs_syscall_iopen(dev, inode, usrmod, rvp, credp)
struct vnode *vp = NULL;
int dummy;
int fd;
register int code;
int code;
dev_t newdev;
AFS_STATCNT(afs_syscall_iopen);
@ -320,7 +320,7 @@ afs_syscall_iincdec(dev, inode, inode_p1, amount, rvp, credp)
{
int dummy;
struct inode *ip;
register afs_int32 code;
afs_int32 code;
dev_t newdev;
if (!afs_osi_suser(credp))

4
src/afs/SOLARIS/osi_vfsops.c
View File

@ -148,9 +148,9 @@ afs_freevfs(struct vfs *afsp)
int
afs_root(struct vfs *afsp, struct vnode **avpp)
{
register afs_int32 code = 0;
afs_int32 code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
struct vcache *gvp;
struct proc *proc = ttoproc(curthread);
struct vnode *vp = afsp->vfs_vnodecovered;

184
src/afs/SOLARIS/osi_vnodeops.c
View File

@ -83,7 +83,7 @@ int afs_dump(), afs_cmp(), afs_realvp(), afs_GetOnePage();
int afs_pvn_vptrunc;
int
afs_addmap(register struct vnode *avp, offset_t offset, struct as *asp,
afs_addmap(struct vnode *avp, offset_t offset, struct as *asp,
caddr_t addr, int length, int prot, int maxprot, int flags,
afs_ucred_t *credp)
{
@ -92,7 +92,7 @@ afs_addmap(register struct vnode *avp, offset_t offset, struct as *asp,
}
int
afs_delmap(register struct vnode *avp, offset_t offset, struct as *asp,
afs_delmap(struct vnode *avp, offset_t offset, struct as *asp,
caddr_t addr, int length, int prot, int maxprot, int flags,
afs_ucred_t *credp)
{
@ -102,15 +102,15 @@ afs_delmap(register struct vnode *avp, offset_t offset, struct as *asp,
#ifdef AFS_SUN510_ENV
int
afs_vmread(register struct vnode *avp, struct uio *auio, int ioflag,
afs_vmread(struct vnode *avp, struct uio *auio, int ioflag,
afs_ucred_t *acred, caller_context_t *ct)
#else
int
afs_vmread(register struct vnode *avp, struct uio *auio, int ioflag,
afs_vmread(struct vnode *avp, struct uio *auio, int ioflag,
afs_ucred_t *acred)
#endif
{
register int code;
int code;
if (!RW_READ_HELD(&(VTOAFS(avp))->rwlock))
osi_Panic("afs_vmread: !rwlock");
@ -123,15 +123,15 @@ afs_vmread(register struct vnode *avp, struct uio *auio, int ioflag,
#ifdef AFS_SUN510_ENV
int
afs_vmwrite(register struct vnode *avp, struct uio *auio, int ioflag,
afs_vmwrite(struct vnode *avp, struct uio *auio, int ioflag,
afs_ucred_t *acred, caller_context_t *ct)
#else
int
afs_vmwrite(register struct vnode *avp, struct uio *auio, int ioflag,
afs_vmwrite(struct vnode *avp, struct uio *auio, int ioflag,
afs_ucred_t *acred)
#endif
{
register int code;
int code;
if (!RW_WRITE_HELD(&(VTOAFS(avp))->rwlock))
osi_Panic("afs_vmwrite: !rwlock");
@ -146,7 +146,7 @@ afs_getpage(struct vnode *vp, offset_t off, u_int len, u_int *protp,
struct page *pl[], u_int plsz, struct seg *seg, caddr_t addr,
enum seg_rw rw, afs_ucred_t *acred)
{
register afs_int32 code = 0;
afs_int32 code = 0;
AFS_STATCNT(afs_getpage);
if (vp->v_flag & VNOMAP) /* File doesn't allow mapping */
@ -194,13 +194,13 @@ afs_GetOnePage(struct vnode *vp, u_int off, u_int alen, u_int *protp,
enum seg_rw rw, afs_ucred_t *acred)
#endif
{
register struct page *page;
register afs_int32 code = 0;
struct page *page;
afs_int32 code = 0;
u_int len;
struct buf *buf;
afs_int32 tlen;
register struct vcache *avc;
register struct dcache *tdc;
struct vcache *avc;
struct dcache *tdc;
int i, s, pexists;
int slot;
afs_size_t offset, nlen = 0;
@ -646,21 +646,21 @@ afs_putapage(struct vnode *vp, struct page *pages, u_int * offp,
}
int
afs_nfsrdwr(register struct vcache *avc, struct uio *auio, enum uio_rw arw,
afs_nfsrdwr(struct vcache *avc, struct uio *auio, enum uio_rw arw,
int ioflag, afs_ucred_t *acred)
{
register afs_int32 code;
afs_int32 code;
afs_int32 code2;
int counter;
afs_int32 mode, sflags;
register char *data;
char *data;
struct dcache *dcp, *dcp_newpage;
afs_size_t fileBase, size;
afs_size_t pageBase;
register afs_int32 tsize;
register afs_int32 pageOffset, extraResid = 0;
register afs_size_t origLength; /* length when reading/writing started */
register long appendLength; /* length when this call will finish */
afs_int32 tsize;
afs_int32 pageOffset, extraResid = 0;
afs_size_t origLength; /* length when reading/writing started */
long appendLength; /* length when this call will finish */
int created; /* created pages instead of faulting them */
int lockCode;
int didFakeOpen, eof;
@ -1013,9 +1013,9 @@ int
afs_map(struct vnode *vp, offset_t off, struct as *as, caddr_t *addr, u_int len, u_char prot, u_char maxprot, u_int flags, afs_ucred_t *cred)
{
struct segvn_crargs crargs;
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
register struct vcache *avc = VTOAFS(vp);
struct vcache *avc = VTOAFS(vp);
AFS_STATCNT(afs_map);
@ -1103,10 +1103,10 @@ afs_map(struct vnode *vp, offset_t off, struct as *as, caddr_t *addr, u_int len,
int
#ifdef AFS_SUN511_ENV
afs_pathconf(struct vnode *vp, int cmd, u_long *outdatap,
register afs_ucred_t *credp, caller_context_t *ct)
afs_ucred_t *credp, caller_context_t *ct)
#else
afs_pathconf(struct vnode *vp, int cmd, u_long *outdatap,
register afs_ucred_t *credp)
afs_ucred_t *credp)
#endif /* AFS_SUN511_ENV */
{
AFS_STATCNT(afs_cntl);
@ -1168,7 +1168,7 @@ afs_rwunlock(struct vnode *vnp, int wlock)
int
afs_seek(struct vnode *vnp, offset_t ooff, offset_t *noffp)
{
register int code = 0;
int code = 0;
#ifndef AFS_64BIT_CLIENT
# define __MAXOFF_T MAXOFF_T
@ -1193,7 +1193,7 @@ afs_frlock(struct vnode *vnp, int cmd, struct flock *ap, int flag,
offset_t off, afs_ucred_t *credp)
#endif
{
register afs_int32 code = 0;
afs_int32 code = 0;
/*
* Implement based on afs_lockctl
*/
@ -1238,7 +1238,7 @@ afs_space(struct vnode *vnp, int cmd, struct flock *ap, int flag,
offset_t off, afs_ucred_t *credp)
#endif
{
register afs_int32 code = EINVAL;
afs_int32 code = EINVAL;
struct vattr vattr;
if ((cmd == F_FREESP)
@ -1345,60 +1345,60 @@ afs_getsecattr(struct vnode *vp, vsecattr_t *vsecattr, int flag, struct cred *cr
#endif
#ifdef AFS_GLOBAL_SUNLOCK
extern int gafs_open(register struct vcache **avcp, afs_int32 aflags,
extern int gafs_open(struct vcache **avcp, afs_int32 aflags,
afs_ucred_t *acred);
extern int gafs_close(register struct vcache *avc, afs_int32 aflags,
extern int gafs_close(struct vcache *avc, afs_int32 aflags,
int count, offset_t offset, afs_ucred_t *acred);
extern int afs_ioctl(struct vnode *vnp, int com, int arg, int flag,
cred_t *credp, int *rvalp);
extern int gafs_access(register struct vcache *avc, register afs_int32 amode,
extern int gafs_access(struct vcache *avc, afs_int32 amode,
int flags, afs_ucred_t *acred);
extern int gafs_getattr(register struct vcache *avc,
register struct vattr *attrs, int flags,
extern int gafs_getattr(struct vcache *avc,
struct vattr *attrs, int flags,
afs_ucred_t *acred);
extern int gafs_setattr(register struct vcache *avc,
register struct vattr *attrs, int flags,
extern int gafs_setattr(struct vcache *avc,
struct vattr *attrs, int flags,
afs_ucred_t *acred);
extern int gafs_lookup(register struct vcache *adp, char *aname,
register struct vcache **avcp, struct pathname *pnp,
extern int gafs_lookup(struct vcache *adp, char *aname,
struct vcache **avcp, struct pathname *pnp,
int flags, struct vnode *rdir, afs_ucred_t *acred);
extern int gafs_remove(register struct vcache *adp, char *aname,
extern int gafs_remove(struct vcache *adp, char *aname,
afs_ucred_t *acred);
extern int gafs_link(register struct vcache *adp, register struct vcache *avc,
extern int gafs_link(struct vcache *adp, struct vcache *avc,
char *aname, afs_ucred_t *acred);
extern int gafs_rename(register struct vcache *aodp, char *aname1,
register struct vcache *andp, char *aname2,
extern int gafs_rename(struct vcache *aodp, char *aname1,
struct vcache *andp, char *aname2,
afs_ucred_t *acred);
extern int gafs_symlink(register struct vcache *adp, char *aname,
struct vattr *attrs, register char *atargetName,
extern int gafs_symlink(struct vcache *adp, char *aname,
struct vattr *attrs, char *atargetName,
afs_ucred_t *acred);
extern int gafs_rmdir(register struct vcache *adp, char *aname,
extern int gafs_rmdir(struct vcache *adp, char *aname,
struct vnode *cdirp, afs_ucred_t *acred);
extern int gafs_mkdir(register struct vcache *adp, char *aname,
struct vattr *attrs, register struct vcache **avcp,
extern int gafs_mkdir(struct vcache *adp, char *aname,
struct vattr *attrs, struct vcache **avcp,
afs_ucred_t *acred);
extern int
#ifdef AFS_SUN53_ENV
gafs_fsync(register struct vcache *avc, int flag, afs_ucred_t *acred);
gafs_fsync(struct vcache *avc, int flag, afs_ucred_t *acred);
#else
gafs_fsync(register struct vcache *avc, afs_ucred_t *acred);
gafs_fsync(struct vcache *avc, afs_ucred_t *acred);
#endif
extern int gafs_readlink(register struct vcache *avc, struct uio *auio,
extern int gafs_readlink(struct vcache *avc, struct uio *auio,
afs_ucred_t *acred);
extern int gafs_readdir(register struct vcache *avc, struct uio *auio,
extern int gafs_readdir(struct vcache *avc, struct uio *auio,
afs_ucred_t *acred, int *eofp);
extern void gafs_inactive(register struct vcache *avc,
extern void gafs_inactive(struct vcache *avc,
afs_ucred_t *acred);
extern int gafs_fid(struct vcache *avc, struct fid **fidpp);
extern int gafs_create(register struct vcache *adp, char *aname,
extern int gafs_create(struct vcache *adp, char *aname,
struct vattr *attrs, enum vcexcl aexcl, int amode,
struct vcache **avcp, afs_ucred_t *acred);
#ifdef AFS_SUN511_ENV
extern int afs_pathconf(struct vnode *vp, int cmd, u_long *outdatap,
register afs_ucred_t *credp, caller_context_t *ct);
afs_ucred_t *credp, caller_context_t *ct);
#else
extern int afs_pathconf(struct vnode *vp, int cmd, u_long *outdatap,
register afs_ucred_t *credp);
afs_ucred_t *credp);
#endif /* AFS_SUN511_ENV */
#if defined(AFS_SUN511_ENV)
@ -1553,10 +1553,10 @@ struct vnodeops *afs_ops = &Afs_vnodeops;
#endif
int
gafs_open(register struct vcache **avcp, afs_int32 aflags,
gafs_open(struct vcache **avcp, afs_int32 aflags,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_open(avcp, aflags, acred);
@ -1565,10 +1565,10 @@ gafs_open(register struct vcache **avcp, afs_int32 aflags,
}
int
gafs_close(register struct vcache *avc, afs_int32 aflags, int count,
gafs_close(struct vcache *avc, afs_int32 aflags, int count,
offset_t offset, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_close(avc, aflags, count, offset, acred);
@ -1577,10 +1577,10 @@ gafs_close(register struct vcache *avc, afs_int32 aflags, int count,
}
int
gafs_getattr(register struct vcache *avc, register struct vattr *attrs,
gafs_getattr(struct vcache *avc, struct vattr *attrs,
int flags, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_getattr(avc, attrs, flags, acred);
@ -1590,10 +1590,10 @@ gafs_getattr(register struct vcache *avc, register struct vattr *attrs,
int
gafs_setattr(register struct vcache *avc, register struct vattr *attrs,
gafs_setattr(struct vcache *avc, struct vattr *attrs,
int flags, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_setattr(avc, attrs, flags, acred);
@ -1603,10 +1603,10 @@ gafs_setattr(register struct vcache *avc, register struct vattr *attrs,
int
gafs_access(register struct vcache *avc, register afs_int32 amode, int flags,
gafs_access(struct vcache *avc, afs_int32 amode, int flags,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_access(avc, amode, flags, acred);
@ -1616,11 +1616,11 @@ gafs_access(register struct vcache *avc, register afs_int32 amode, int flags,
int
gafs_lookup(register struct vcache *adp, char *aname,
register struct vcache **avcp, struct pathname *pnp, int flags,
gafs_lookup(struct vcache *adp, char *aname,
struct vcache **avcp, struct pathname *pnp, int flags,
struct vnode *rdir, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_lookup(adp, aname, avcp, pnp, flags, rdir, acred);
@ -1630,11 +1630,11 @@ gafs_lookup(register struct vcache *adp, char *aname,
int
gafs_create(register struct vcache *adp, char *aname, struct vattr *attrs,
gafs_create(struct vcache *adp, char *aname, struct vattr *attrs,
enum vcexcl aexcl, int amode, struct vcache **avcp,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_create(adp, aname, attrs, aexcl, amode, avcp, acred);
@ -1643,9 +1643,9 @@ gafs_create(register struct vcache *adp, char *aname, struct vattr *attrs,
}
int
gafs_remove(register struct vcache *adp, char *aname, afs_ucred_t *acred)
gafs_remove(struct vcache *adp, char *aname, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_remove(adp, aname, acred);
@ -1654,10 +1654,10 @@ gafs_remove(register struct vcache *adp, char *aname, afs_ucred_t *acred)
}
int
gafs_link(register struct vcache *adp, register struct vcache *avc,
gafs_link(struct vcache *adp, struct vcache *avc,
char *aname, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_link(adp, avc, aname, acred);
@ -1666,11 +1666,11 @@ gafs_link(register struct vcache *adp, register struct vcache *avc,
}
int
gafs_rename(register struct vcache *aodp, char *aname1,
register struct vcache *andp, char *aname2,
gafs_rename(struct vcache *aodp, char *aname1,
struct vcache *andp, char *aname2,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_rename(aodp, aname1, andp, aname2, acred);
@ -1699,10 +1699,10 @@ gafs_rename(register struct vcache *aodp, char *aname1,
}
int
gafs_mkdir(register struct vcache *adp, char *aname, struct vattr *attrs,
register struct vcache **avcp, afs_ucred_t *acred)
gafs_mkdir(struct vcache *adp, char *aname, struct vattr *attrs,
struct vcache **avcp, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_mkdir(adp, aname, attrs, avcp, acred);
@ -1711,10 +1711,10 @@ gafs_mkdir(register struct vcache *adp, char *aname, struct vattr *attrs,
}
int
gafs_rmdir(register struct vcache *adp, char *aname, struct vnode *cdirp,
gafs_rmdir(struct vcache *adp, char *aname, struct vnode *cdirp,
afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_rmdir(adp, aname, cdirp, acred);
@ -1724,10 +1724,10 @@ gafs_rmdir(register struct vcache *adp, char *aname, struct vnode *cdirp,
int
gafs_readdir(register struct vcache *avc, struct uio *auio,
gafs_readdir(struct vcache *avc, struct uio *auio,
afs_ucred_t *acred, int *eofp)
{
register int code;
int code;
AFS_GLOCK();
code = afs_readdir(avc, auio, acred, eofp);
@ -1736,10 +1736,10 @@ gafs_readdir(register struct vcache *avc, struct uio *auio,
}
int
gafs_symlink(register struct vcache *adp, char *aname, struct vattr *attrs,
register char *atargetName, afs_ucred_t *acred)
gafs_symlink(struct vcache *adp, char *aname, struct vattr *attrs,
char *atargetName, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_symlink(adp, aname, attrs, atargetName, acred);
@ -1749,9 +1749,9 @@ gafs_symlink(register struct vcache *adp, char *aname, struct vattr *attrs,
int
gafs_readlink(register struct vcache *avc, struct uio *auio, afs_ucred_t *acred)
gafs_readlink(struct vcache *avc, struct uio *auio, afs_ucred_t *acred)
{
register int code;
int code;
AFS_GLOCK();
code = afs_readlink(avc, auio, acred);
@ -1761,12 +1761,12 @@ gafs_readlink(register struct vcache *avc, struct uio *auio, afs_ucred_t *acred)
int
#ifdef AFS_SUN53_ENV
gafs_fsync(register struct vcache *avc, int flag, afs_ucred_t *acred)
gafs_fsync(struct vcache *avc, int flag, afs_ucred_t *acred)
#else
gafs_fsync(register struct vcache *avc, afs_ucred_t *acred)
gafs_fsync(struct vcache *avc, afs_ucred_t *acred)
#endif
{
register int code;
int code;
AFS_GLOCK();
#ifdef AFS_SUN53_ENV
@ -1828,7 +1828,7 @@ afs_inactive(struct vcache *avc, afs_ucred_t *acred)
}
void
gafs_inactive(register struct vcache *avc, afs_ucred_t *acred)
gafs_inactive(struct vcache *avc, afs_ucred_t *acred)
{
AFS_GLOCK();
(void)afs_inactive(avc, acred);
@ -1839,7 +1839,7 @@ gafs_inactive(register struct vcache *avc, afs_ucred_t *acred)
int
gafs_fid(struct vcache *avc, struct fid **fidpp)
{
register int code;
int code;
AFS_GLOCK();
code = afs_fid(avc, fidpp);

4
src/afs/UKERNEL/afs_usrops.c
View File

@ -978,7 +978,7 @@ afs_osi_MapStrategy(int (*aproc) (struct usr_buf *), struct usr_buf *bp)
}
void
osi_FlushPages(register struct vcache *avc, afs_ucred_t *credp)
osi_FlushPages(struct vcache *avc, afs_ucred_t *credp)
{
ObtainSharedLock(&avc->lock, 555);
if ((hcmp((avc->f.m.DataVersion), (avc->mapDV)) <= 0)
@ -993,7 +993,7 @@ osi_FlushPages(register struct vcache *avc, afs_ucred_t *credp)
}
void
osi_FlushText_really(register struct vcache *vp)
osi_FlushText_really(struct vcache *vp)
{
if (hcmp(vp->f.m.DataVersion, vp->flushDV) > 0) {
hset(vp->flushDV, vp->f.m.DataVersion);

2
src/afs/UKERNEL/osi_prototypes.h
View File

@ -19,7 +19,7 @@ extern int afs_mount(struct vfs *afsp, char *path, void *data);
extern int afs_unmount(struct vfs *afsp);
extern int afs_root(OSI_VFS_DECL(afsp), struct vnode **avpp);
extern int afs_sync(struct vfs *afsp);
extern int afs_statfs(register struct vfs *afsp, struct statfs *abp);
extern int afs_statfs(struct vfs *afsp, struct statfs *abp);
extern int afs_mountroot(void);
extern int afs_swapvp(void);

6
src/afs/UKERNEL/osi_vfsops.c
View File

@ -60,9 +60,9 @@ afs_unmount(struct vfs *afsp)
int
afs_root(OSI_VFS_DECL(afsp), struct vnode **avpp)
{
register afs_int32 code = 0;
afs_int32 code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
struct vcache *tvp = 0;
OSI_VFS_CONVERT(afsp);
AFS_STATCNT(afs_root);
@ -105,7 +105,7 @@ afs_sync(struct vfs *afsp)
}
int
afs_statfs(register struct vfs *afsp, struct statfs *abp)
afs_statfs(struct vfs *afsp, struct statfs *abp)
{
AFS_STATCNT(afs_statfs);
abp->f_type = 0;

20
src/afs/VNOPS/afs_vnop_access.c
View File

@ -51,8 +51,8 @@ static char fileModeMap[8] = {
/* avc must be held. Returns bit map of mode bits. Ignores file mode bits */
afs_int32
afs_GetAccessBits(register struct vcache *avc, register afs_int32 arights,
register struct vrequest *areq)
afs_GetAccessBits(struct vcache *avc, afs_int32 arights,
struct vrequest *areq)
{
AFS_STATCNT(afs_GetAccessBits);
/* see if anyuser has the required access bits */
@ -110,11 +110,11 @@ int
afs_AccessOK(struct vcache *avc, afs_int32 arights, struct vrequest *areq,
afs_int32 check_mode_bits)
{
register struct vcache *tvc;
struct vcache *tvc;
struct VenusFid dirFid;
register afs_int32 mask;
afs_int32 mask;
afs_int32 dirBits;
register afs_int32 fileBits;
afs_int32 fileBits;
AFS_STATCNT(afs_AccessOK);
@ -190,15 +190,15 @@ afs_AccessOK(struct vcache *avc, afs_int32 arights, struct vrequest *areq,
#if defined(AFS_SUN5_ENV) || (defined(AFS_SGI_ENV) && !defined(AFS_SGI65_ENV))
int
afs_access(OSI_VC_DECL(avc), register afs_int32 amode, int flags,
afs_access(OSI_VC_DECL(avc), afs_int32 amode, int flags,
afs_ucred_t *acred)
#else
int
afs_access(OSI_VC_DECL(avc), register afs_int32 amode,
afs_access(OSI_VC_DECL(avc), afs_int32 amode,
afs_ucred_t *acred)
#endif
{
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
struct afs_fakestat_state fakestate;
OSI_VC_CONVERT(avc);
@ -338,10 +338,10 @@ afs_access(OSI_VC_DECL(avc), register afs_int32 amode,
* This function is just an interface to afs_GetAccessBits
*/
int
afs_getRights(OSI_VC_DECL(avc), register afs_int32 arights,
afs_getRights(OSI_VC_DECL(avc), afs_int32 arights,
afs_ucred_t *acred)
{
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
OSI_VC_CONVERT(avc);

20
src/afs/VNOPS/afs_vnop_attrs.c
View File

@ -41,10 +41,10 @@ extern struct vfs *afs_globalVFS;
/* copy out attributes from cache entry */
int
afs_CopyOutAttrs(register struct vcache *avc, register struct vattr *attrs)
afs_CopyOutAttrs(struct vcache *avc, struct vattr *attrs)
{
register struct volume *tvp;
register struct cell *tcell;
struct volume *tvp;
struct cell *tcell;
int fakedir = 0;
AFS_STATCNT(afs_CopyOutAttrs);
@ -268,7 +268,7 @@ afs_getattr(OSI_VC_DECL(avc), struct vattr *attrs, afs_ucred_t *acred)
}
}
if ((au = afs_FindUser(treq.uid, -1, READ_LOCK))) {
register struct afs_exporter *exporter = au->exporter;
struct afs_exporter *exporter = au->exporter;
if (exporter && !(afs_nfsexporter->exp_states & EXP_UNIXMODE)) {
unsigned int ubits;
@ -336,10 +336,10 @@ afs_getattr(OSI_VC_DECL(avc), struct vattr *attrs, afs_ucred_t *acred)
/* convert a Unix request into a status store request */
int
afs_VAttrToAS(register struct vcache *avc, register struct vattr *av,
register struct AFSStoreStatus *as)
afs_VAttrToAS(struct vcache *avc, struct vattr *av,
struct AFSStoreStatus *as)
{
register int mask;
int mask;
mask = 0;
AFS_STATCNT(afs_VAttrToAS);
#if defined(AFS_DARWIN80_ENV)
@ -434,17 +434,17 @@ afs_VAttrToAS(register struct vcache *avc, register struct vattr *av,
*/
#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
int
afs_setattr(OSI_VC_DECL(avc), register struct vattr *attrs, int flags,
afs_setattr(OSI_VC_DECL(avc), struct vattr *attrs, int flags,
afs_ucred_t *acred)
#else
int
afs_setattr(OSI_VC_DECL(avc), register struct vattr *attrs,
afs_setattr(OSI_VC_DECL(avc), struct vattr *attrs,
afs_ucred_t *acred)
#endif
{
struct vrequest treq;
struct AFSStoreStatus astat;
register afs_int32 code;
afs_int32 code;
struct afs_fakestat_state fakestate;
OSI_VC_CONVERT(avc);

10
src/afs/VNOPS/afs_vnop_create.c
View File

@ -42,8 +42,8 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
{
afs_int32 origCBs, origZaps, finalZaps;
struct vrequest treq;
register afs_int32 code;
register struct afs_conn *tc;
afs_int32 code;
struct afs_conn *tc;
struct VenusFid newFid;
struct AFSStoreStatus InStatus;
struct AFSFetchStatus OutFidStatus, OutDirStatus;
@ -510,10 +510,10 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
* and dcache entry write-locked.
*/
int
afs_LocalHero(register struct vcache *avc, register struct dcache *adc,
register AFSFetchStatus * astat, register int aincr)
afs_LocalHero(struct vcache *avc, struct dcache *adc,
AFSFetchStatus * astat, int aincr)
{
register afs_int32 ok;
afs_int32 ok;
afs_hyper_t avers;
AFS_STATCNT(afs_LocalHero);

18
src/afs/VNOPS/afs_vnop_dirops.c
View File

@ -35,16 +35,16 @@ extern afs_rwlock_t afs_xcbhash;
int
afs_mkdir(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
register struct vcache **avcp, afs_ucred_t *acred)
struct vcache **avcp, afs_ucred_t *acred)
{
struct vrequest treq;
register afs_int32 code;
register struct afs_conn *tc;
afs_int32 code;
struct afs_conn *tc;
struct VenusFid newFid;
register struct dcache *tdc;
struct dcache *tdc;
struct dcache *new_dc;
afs_size_t offset, len;
register struct vcache *tvc;
struct vcache *tvc;
struct AFSStoreStatus InStatus;
struct AFSFetchStatus OutFidStatus, OutDirStatus;
struct AFSCallBack CallBack;
@ -255,10 +255,10 @@ afs_rmdir(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred)
#endif
{
struct vrequest treq;
register struct dcache *tdc;
register struct vcache *tvc = NULL;
register afs_int32 code;
register struct afs_conn *tc;
struct dcache *tdc;
struct vcache *tvc = NULL;
afs_int32 code;
struct afs_conn *tc;
afs_size_t offset, len;
struct AFSFetchStatus OutDirStatus;
struct AFSVolSync tsync;

2
src/afs/VNOPS/afs_vnop_fid.c
View File

@ -76,7 +76,7 @@ afs_fid(OSI_VC_DECL(avc), struct fid **fidpp)
{
struct SmallFid Sfid;
long addr[2];
register struct cell *tcell;
struct cell *tcell;
extern struct vcache *afs_globalVp;
int SizeOfSmallFid = SIZEOF_SMALLFID;
int rootvp = 0;

28
src/afs/VNOPS/afs_vnop_flock.c
View File

@ -29,12 +29,12 @@
/* Static prototypes */
static int HandleGetLock(register struct vcache *avc,
register struct AFS_FLOCK *af,
register struct vrequest *areq, int clid);
static int HandleGetLock(struct vcache *avc,
struct AFS_FLOCK *af,
struct vrequest *areq, int clid);
static int GetFlockCount(struct vcache *avc, struct vrequest *areq);
static int lockIdcmp2(struct AFS_FLOCK *flock1, struct vcache *vp,
register struct SimpleLocks *alp, int onlymine,
struct SimpleLocks *alp, int onlymine,
int clid);
static void DoLockWarning(afs_ucred_t * acred);
@ -178,11 +178,11 @@ lockIdSet(struct AFS_FLOCK *flock, struct SimpleLocks *slp, int clid)
static int
lockIdcmp2(struct AFS_FLOCK *flock1, struct vcache *vp,
register struct SimpleLocks *alp, int onlymine, int clid)
struct SimpleLocks *alp, int onlymine, int clid)
{
register struct SimpleLocks *slp;
struct SimpleLocks *slp;
#if defined(AFS_SUN5_ENV)
register proc_t *procp = ttoproc(curthread);
proc_t *procp = ttoproc(curthread);
#else
#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
#ifdef AFS_SGI64_ENV
@ -251,7 +251,7 @@ lockIdcmp2(struct AFS_FLOCK *flock1, struct vcache *vp,
*/
/* clid - nonzero on sgi sunos osf1 only */
int
HandleFlock(register struct vcache *avc, int acom, struct vrequest *areq,
HandleFlock(struct vcache *avc, int acom, struct vrequest *areq,
pid_t clid, int onlymine)
{
struct afs_conn *tc;
@ -504,7 +504,7 @@ static afs_int32 lastWarnPid = 0;
static void
DoLockWarning(afs_ucred_t * acred)
{
register afs_int32 now;
afs_int32 now;
pid_t pid = MyPidxx2Pid(MyPidxx);
char *procname;
@ -639,10 +639,10 @@ done:
* PID has the file read locked.
*/
static int
HandleGetLock(register struct vcache *avc, register struct AFS_FLOCK *af,
register struct vrequest *areq, int clid)
HandleGetLock(struct vcache *avc, struct AFS_FLOCK *af,
struct vrequest *areq, int clid)
{
register afs_int32 code;
afs_int32 code;
struct AFS_FLOCK flock;
lockIdSet(&flock, NULL, clid);
@ -838,8 +838,8 @@ HandleGetLock(register struct vcache *avc, register struct AFS_FLOCK *af,
static int
GetFlockCount(struct vcache *avc, struct vrequest *areq)
{
register struct afs_conn *tc;
register afs_int32 code;
struct afs_conn *tc;
afs_int32 code;
struct AFSFetchStatus OutStatus;
struct AFSCallBack CallBack;
struct AFSVolSync tsync;

6
src/afs/VNOPS/afs_vnop_link.c
View File

@ -39,9 +39,9 @@ afs_link(struct vcache *avc, OSI_VC_DECL(adp), char *aname,
#endif
{
struct vrequest treq;
register struct dcache *tdc;
register afs_int32 code;
register struct afs_conn *tc;
struct dcache *tdc;
afs_int32 code;
struct afs_conn *tc;
afs_size_t offset, len;
struct AFSFetchStatus OutFidStatus, OutDirStatus;
struct AFSVolSync tsync;

36
src/afs/VNOPS/afs_vnop_lookup.c
View File

@ -50,7 +50,7 @@ int afs_fakestat_enable = 0; /* 1: fakestat-all, 2: fakestat-crosscell */
*/
static int
EvalMountData(char type, char *data, afs_uint32 states, afs_uint32 cellnum,
struct volume **avolpp, register struct vrequest *areq,
struct volume **avolpp, struct vrequest *areq,
afs_uint32 *acellidxp, afs_uint32 *avolnump,
afs_uint32 *avnoidp, afs_uint32 *auniqp)
{
@ -271,8 +271,8 @@ done:
}
int
EvalMountPoint(register struct vcache *avc, struct vcache *advc,
struct volume **avolpp, register struct vrequest *areq)
EvalMountPoint(struct vcache *avc, struct vcache *advc,
struct volume **avolpp, struct vrequest *areq)
{
afs_int32 code;
afs_uint32 avnoid, auniq;
@ -503,9 +503,9 @@ afs_PutFakeStat(struct afs_fakestat_state *state)
}
int
afs_ENameOK(register char *aname)
afs_ENameOK(char *aname)
{
register int tlen;
int tlen;
AFS_STATCNT(ENameOK);
tlen = strlen(aname);
@ -515,11 +515,11 @@ afs_ENameOK(register char *aname)
}
static int
afs_getsysname(register struct vrequest *areq, register struct vcache *adp,
register char *bufp, int *num, char **sysnamelist[])
afs_getsysname(struct vrequest *areq, struct vcache *adp,
char *bufp, int *num, char **sysnamelist[])
{
register struct unixuser *au;
register afs_int32 error;
struct unixuser *au;
afs_int32 error;
AFS_STATCNT(getsysname);
@ -546,7 +546,7 @@ afs_getsysname(register struct vrequest *areq, register struct vcache *adp,
}
void
Check_AtSys(register struct vcache *avc, const char *aname,
Check_AtSys(struct vcache *avc, const char *aname,
struct sysname_info *state, struct vrequest *areq)
{
int num = 0;
@ -567,7 +567,7 @@ Check_AtSys(register struct vcache *avc, const char *aname,
}
int
Next_AtSys(register struct vcache *avc, struct vrequest *areq,
Next_AtSys(struct vcache *avc, struct vrequest *areq,
struct sysname_info *state)
{
int num = afs_sysnamecount;
@ -578,7 +578,7 @@ Next_AtSys(register struct vcache *avc, struct vrequest *areq,
/* Check for the initial state of aname != "@sys" in Check_AtSys */
if (state->offset == -1 && state->allocked == 0) {
register char *tname;
char *tname;
/* Check for .*@sys */
for (tname = state->name; *tname; tname++)
@ -598,8 +598,8 @@ Next_AtSys(register struct vcache *avc, struct vrequest *areq,
} else
return 0; /* .*@sys doesn't match either */
} else {
register struct unixuser *au;
register afs_int32 error;
struct unixuser *au;
afs_int32 error;
*sysnamelist = afs_sysnamelist;
@ -1316,9 +1316,9 @@ afs_lookup(OSI_VC_DECL(adp), char *aname, struct vcache **avcp, afs_ucred_t *acr
{
struct vrequest treq;
char *tname = NULL;
register struct vcache *tvc = 0;
register afs_int32 code;
register afs_int32 bulkcode = 0;
struct vcache *tvc = 0;
afs_int32 code;
afs_int32 bulkcode = 0;
int pass = 0, hit = 0;
int force_eval = afs_fakestat_enable ? 0 : 1;
long dirCookie;
@ -1553,7 +1553,7 @@ afs_lookup(OSI_VC_DECL(adp), char *aname, struct vcache **avcp, afs_ucred_t *acr
}
{ /* sub-block just to reduce stack usage */
register struct dcache *tdc;
struct dcache *tdc;
afs_size_t dirOffset, dirLen;
struct VenusFid tfid;

4
src/afs/VNOPS/afs_vnop_open.c
View File

@ -39,7 +39,7 @@ afs_open(bhv_desc_t * bhv, struct vcache **avcp, afs_int32 aflags,
afs_open(struct vcache **avcp, afs_int32 aflags, afs_ucred_t *acred)
#endif
{
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
struct vcache *tvc;
int writing;
@ -166,7 +166,7 @@ afs_open(struct vcache **avcp, afs_int32 aflags, afs_ucred_t *acred)
ReleaseReadLock(&tvc->lock);
if ((afs_preCache != 0) && (writing == 0) && (vType(tvc) != VDIR) &&
(!afs_BBusy())) {
register struct dcache *tdc;
struct dcache *tdc;
afs_size_t offset, len;
tdc = afs_GetDCache(tvc, 0, &treq, &offset, &len, 1);

6
src/afs/VNOPS/afs_vnop_read.c
View File

@ -42,7 +42,7 @@ void afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
afs_ucred_t *acred, struct vrequest *areq);
int
afs_MemRead(register struct vcache *avc, struct uio *auio,
afs_MemRead(struct vcache *avc, struct uio *auio,
afs_ucred_t *acred, daddr_t albn, struct buf **abpp,
int noLock)
{
@ -418,7 +418,7 @@ void
afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
afs_ucred_t *acred, struct vrequest *areq)
{
register struct dcache *tdc;
struct dcache *tdc;
afs_size_t offset;
afs_size_t j1, j2; /* junk vbls for GetDCache to trash */
@ -486,7 +486,7 @@ afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
}
int
afs_UFSRead(register struct vcache *avc, struct uio *auio,
afs_UFSRead(struct vcache *avc, struct uio *auio,
afs_ucred_t *acred, daddr_t albn, struct buf **abpp,
int noLock)
{

10
src/afs/VNOPS/afs_vnop_readdir.c
View File

@ -66,10 +66,10 @@
int
BlobScan(struct dcache * afile, afs_int32 ablob)
{
register afs_int32 relativeBlob;
afs_int32 relativeBlob;
afs_int32 pageBlob;
register struct PageHeader *tpe;
register afs_int32 i;
struct PageHeader *tpe;
afs_int32 i;
AFS_STATCNT(BlobScan);
/* advance ablob over free and header blobs */
@ -582,7 +582,7 @@ afs_readdir(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
#endif
{
struct vrequest treq;
register struct dcache *tdc;
struct dcache *tdc;
afs_size_t origOffset, tlen;
afs_int32 len;
int code = 0;
@ -927,7 +927,7 @@ int
afs1_readdir(struct vcache *avc, struct uio *auio, afs_ucred_t *acred)
{
struct vrequest treq;
register struct dcache *tdc;
struct dcache *tdc;
afs_size_t origOffset, len;
int code = 0;
struct DirEntry *ode = 0, *nde = 0;

24
src/afs/VNOPS/afs_vnop_remove.c
View File

@ -32,10 +32,10 @@ extern afs_rwlock_t afs_xcbhash;
static void
FetchWholeEnchilada(register struct vcache *avc, struct vrequest *areq)
FetchWholeEnchilada(struct vcache *avc, struct vrequest *areq)
{
register afs_int32 nextChunk;
register struct dcache *tdc;
afs_int32 nextChunk;
struct dcache *tdc;
afs_size_t pos, offset, len;
AFS_STATCNT(FetchWholeEnchilada);
@ -53,12 +53,12 @@ FetchWholeEnchilada(register struct vcache *avc, struct vrequest *areq)
}
int
afsremove(register struct vcache *adp, register struct dcache *tdc,
register struct vcache *tvc, char *aname, afs_ucred_t *acred,
afsremove(struct vcache *adp, struct dcache *tdc,
struct vcache *tvc, char *aname, afs_ucred_t *acred,
struct vrequest *treqp)
{
register afs_int32 code = 0;
register struct afs_conn *tc;
afs_int32 code = 0;
struct afs_conn *tc;
struct AFSFetchStatus OutDirStatus;
struct AFSVolSync tsync;
XSTATS_DECLS;
@ -175,10 +175,10 @@ int
afs_remove(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred)
{
struct vrequest treq;
register struct dcache *tdc;
struct dcache *tdc;
struct VenusFid unlinkFid;
register afs_int32 code;
register struct vcache *tvc;
afs_int32 code;
struct vcache *tvc;
afs_size_t offset, len;
struct afs_fakestat_state fakestate;
OSI_VC_CONVERT(adp);
@ -396,14 +396,14 @@ afs_remove(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred)
* CAUTION -- may be called with avc unheld. */
int
afs_remunlink(register struct vcache *avc, register int doit)
afs_remunlink(struct vcache *avc, int doit)
{
afs_ucred_t *cred;
char *unlname;
struct vcache *adp;
struct vrequest treq;
struct VenusFid dirFid;
register struct dcache *tdc;
struct dcache *tdc;
afs_int32 code = 0;
if (NBObtainWriteLock(&avc->lock, 423))

6
src/afs/VNOPS/afs_vnop_rename.c
View File

@ -34,8 +34,8 @@ int
afsrename(struct vcache *aodp, char *aname1, struct vcache *andp,
char *aname2, afs_ucred_t *acred, struct vrequest *areq)
{
register struct afs_conn *tc;
register afs_int32 code = 0;
struct afs_conn *tc;
afs_int32 code = 0;
afs_int32 returnCode;
int oneDir, doLocally;
afs_size_t offset, len;
@ -445,7 +445,7 @@ afs_rename(OSI_VC_DECL(aodp), char *aname1, struct vcache *andp, char *aname2, s
afs_rename(OSI_VC_DECL(aodp), char *aname1, struct vcache *andp, char *aname2, afs_ucred_t *acred)
#endif
{
register afs_int32 code;
afs_int32 code;
struct afs_fakestat_state ofakestate;
struct afs_fakestat_state nfakestate;
struct vrequest treq;

10
src/afs/VNOPS/afs_vnop_strategy.c
View File

@ -28,16 +28,16 @@
#if defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
int afs_ustrategy(register struct buf *abp, afs_ucred_t *credp)
int afs_ustrategy(struct buf *abp, afs_ucred_t *credp)
#else
int afs_ustrategy(register struct buf *abp)
int afs_ustrategy(struct buf *abp)
#endif
{
register afs_int32 code;
afs_int32 code;
struct uio tuio;
struct iovec tiovec[1];
register struct vcache *tvc = VTOAFS(abp->b_vp);
register afs_int32 len = abp->b_bcount;
struct vcache *tvc = VTOAFS(abp->b_vp);
afs_int32 len = abp->b_bcount;
#ifdef AFS_AIX41_ENV
struct ucred *credp;
#elif defined(UKERNEL)

20
src/afs/VNOPS/afs_vnop_symlink.c
View File

@ -295,13 +295,13 @@ afs_symlink(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
}
int
afs_MemHandleLink(register struct vcache *avc, struct vrequest *areq)
afs_MemHandleLink(struct vcache *avc, struct vrequest *areq)
{
register struct dcache *tdc;
register char *tp, *rbuf;
struct dcache *tdc;
char *tp, *rbuf;
afs_size_t offset, len;
afs_int32 tlen, alen;
register afs_int32 code;
afs_int32 code;
AFS_STATCNT(afs_MemHandleLink);
/* two different formats, one for links protected 644, have a "." at
@ -345,14 +345,14 @@ afs_MemHandleLink(register struct vcache *avc, struct vrequest *areq)
}
int
afs_UFSHandleLink(register struct vcache *avc, struct vrequest *areq)
afs_UFSHandleLink(struct vcache *avc, struct vrequest *areq)
{
register struct dcache *tdc;
register char *tp, *rbuf;
struct dcache *tdc;
char *tp, *rbuf;
void *tfile;
afs_size_t offset, len;
afs_int32 tlen, alen;
register afs_int32 code;
afs_int32 code;
/* two different formats, one for links protected 644, have a "." at the
* end of the file name, which we turn into a null. Others, protected
@ -403,9 +403,9 @@ afs_UFSHandleLink(register struct vcache *avc, struct vrequest *areq)
int
afs_readlink(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
{
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
register char *tp;
char *tp;
struct afs_fakestat_state fakestat;
OSI_VC_CONVERT(avc);

26
src/afs/VNOPS/afs_vnop_write.c
View File

@ -36,8 +36,8 @@ extern unsigned char *afs_indexFlags;
* avc->lock must be write-locked.
*/
int
afs_StoreOnLastReference(register struct vcache *avc,
register struct vrequest *treq)
afs_StoreOnLastReference(struct vcache *avc,
struct vrequest *treq)
{
int code = 0;
@ -95,7 +95,7 @@ afs_StoreOnLastReference(register struct vcache *avc,
}
int
afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
afs_MemWrite(struct vcache *avc, struct uio *auio, int aio,
afs_ucred_t *acred, int noLock)
{
afs_size_t totalLength;
@ -105,7 +105,7 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
afs_int32 tlen, trimlen;
afs_int32 startDate;
afs_int32 max;
register struct dcache *tdc;
struct dcache *tdc;
#ifdef _HIGHC_
volatile
#endif
@ -117,7 +117,7 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
struct uio *tuiop = &tuio;
struct iovec *tvec; /* again, should have define */
#endif
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
AFS_STATCNT(afs_MemWrite);
@ -305,7 +305,7 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
/* called on writes */
int
afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
afs_UFSWrite(struct vcache *avc, struct uio *auio, int aio,
afs_ucred_t *acred, int noLock)
{
afs_size_t totalLength;
@ -316,7 +316,7 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
afs_int32 trimlen;
afs_int32 startDate;
afs_int32 max;
register struct dcache *tdc;
struct dcache *tdc;
#ifdef _HIGHC_
volatile
#endif
@ -329,7 +329,7 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
struct iovec *tvec; /* again, should have define */
#endif
struct osi_file *tfile;
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
AFS_STATCNT(afs_UFSWrite);
@ -630,9 +630,9 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
/* do partial write if we're low on unmodified chunks */
int
afs_DoPartialWrite(register struct vcache *avc, struct vrequest *areq)
afs_DoPartialWrite(struct vcache *avc, struct vrequest *areq)
{
register afs_int32 code;
afs_int32 code;
if (afs_stats_cmperf.cacheCurrDirtyChunks <=
afs_stats_cmperf.cacheMaxDirtyChunks
@ -668,8 +668,8 @@ afs_close(OSI_VC_DECL(avc), afs_int32 aflags, int count, offset_t offset,
afs_close(OSI_VC_DECL(avc), afs_int32 aflags, afs_ucred_t *acred)
#endif
{
register afs_int32 code;
register struct brequest *tb;
afs_int32 code;
struct brequest *tb;
struct vrequest treq;
#ifdef AFS_SGI65_ENV
struct flid flid;
@ -836,7 +836,7 @@ afs_fsync(OSI_VC_DECL(avc), int flag, afs_ucred_t *acred
afs_fsync(OSI_VC_DECL(avc), afs_ucred_t *acred)
#endif
{
register afs_int32 code;
afs_int32 code;
struct vrequest treq;
OSI_VC_CONVERT(avc);

4
src/afs/afs_analyze.c
View File

@ -305,8 +305,8 @@ afs_BlackListOnce(struct vrequest *areq, struct VenusFid *afid,
* if this is a temporary or permanent error.
*------------------------------------------------------------------------*/
int
afs_Analyze(register struct afs_conn *aconn, afs_int32 acode,
struct VenusFid *afid, register struct vrequest *areq, int op,
afs_Analyze(struct afs_conn *aconn, afs_int32 acode,
struct VenusFid *afid, struct vrequest *areq, int op,
afs_int32 locktype, struct cell *cellp)
{
afs_int32 i;

2
src/afs/afs_axscache.c
View File

@ -32,7 +32,7 @@ afs_rwlock_t afs_xaxs;
struct axscache *
afs_SlowFindAxs(struct axscache **cachep, afs_int32 id)
{
register struct axscache *i, *j;
struct axscache *i, *j;
j = (*cachep);
i = j->next;

50
src/afs/afs_buffer.c
View File

@ -101,15 +101,15 @@ static afs_int32 timecounter;
/* Prototypes for static routines */
static struct buffer *afs_newslot(struct dcache *adc, afs_int32 apage,
register struct buffer *lp);
struct buffer *lp);
static int dinit_flag = 0;
void
DInit(int abuffers)
{
/* Initialize the venus buffer system. */
register int i;
register struct buffer *tb;
int i;
struct buffer *tb;
AFS_STATCNT(DInit);
if (dinit_flag)
@ -145,10 +145,10 @@ DInit(int abuffers)
}
void *
DRead(register struct dcache *adc, register int page)
DRead(struct dcache *adc, int page)
{
/* Read a page from the disk. */
register struct buffer *tb, *tb2;
struct buffer *tb, *tb2;
struct osi_file *tfile;
int code;
@ -174,7 +174,7 @@ DRead(register struct dcache *adc, register int page)
ReleaseWriteLock(&tb->lock);
return tb->data;
} else {
register struct buffer **bufhead;
struct buffer **bufhead;
bufhead = &(phTable[pHash(adc->index, page)]);
while ((tb2 = tb->hashNext)) {
if (bufmatch(tb2)) {
@ -245,10 +245,10 @@ DRead(register struct dcache *adc, register int page)
}
static void
FixupBucket(register struct buffer *ap)
FixupBucket(struct buffer *ap)
{
register struct buffer **lp, *tp;
register int i;
struct buffer **lp, *tp;
int i;
/* first try to get it out of its current hash bucket, in which it
* might not be */
AFS_STATCNT(FixupBucket);
@ -270,12 +270,12 @@ FixupBucket(register struct buffer *ap)
/* lp is pointer to a fairly-old buffer */
static struct buffer *
afs_newslot(struct dcache *adc, afs_int32 apage, register struct buffer *lp)
afs_newslot(struct dcache *adc, afs_int32 apage, struct buffer *lp)
{
/* Find a usable buffer slot */
register afs_int32 i;
afs_int32 i;
afs_int32 lt = 0;
register struct buffer *tp;
struct buffer *tp;
struct osi_file *tfile;
AFS_STATCNT(afs_newslot);
@ -379,9 +379,9 @@ DRelease(void *loc, int flag)
{
/* Release a buffer, specifying whether or not the buffer has been
* modified by the locker. */
register struct buffer *bp = (struct buffer *)loc;
register int index;
register struct buffer *tp;
struct buffer *bp = (struct buffer *)loc;
int index;
struct buffer *tp;
AFS_STATCNT(DRelease);
if (!bp)
@ -407,11 +407,11 @@ DRelease(void *loc, int flag)
}
int
DVOffset(register void *ap)
DVOffset(void *ap)
{
/* Return the byte within a file represented by a buffer pointer. */
register int index;
register struct buffer *tp;
int index;
struct buffer *tp;
AFS_STATCNT(DVOffset);
/* look for buffer by scanning Unix buffers for appropriate address */
/* see comment in DRelease about the meaning of ap/bp */
@ -444,9 +444,9 @@ DVOffset(register void *ap)
void
DZap(struct dcache *adc)
{
register int i;
int i;
/* Destroy all buffers pertaining to a particular fid. */
register struct buffer *tb;
struct buffer *tb;
AFS_STATCNT(DZap);
ObtainReadLock(&afs_bufferLock);
@ -504,8 +504,8 @@ void
DFlush(void)
{
/* Flush all the modified buffers. */
register int i;
register struct buffer *tb;
int i;
struct buffer *tb;
AFS_STATCNT(DFlush);
tb = Buffers;
@ -538,10 +538,10 @@ DFlush(void)
}
void *
DNew(register struct dcache *adc, register int page)
DNew(struct dcache *adc, int page)
{
/* Same as read, only do *not* even try to read the page, since it probably doesn't exist. */
register struct buffer *tb;
struct buffer *tb;
AFS_STATCNT(DNew);
ObtainWriteLock(&afs_bufferLock, 264);
if ((tb = afs_newslot(adc, page, NULL)) == 0) {
@ -567,7 +567,7 @@ DNew(register struct dcache *adc, register int page)
void
shutdown_bufferpackage(void)
{
register struct buffer *tp;
struct buffer *tp;
int i;
AFS_STATCNT(shutdown_bufferpackage);

26
src/afs/afs_bypasscache.c
View File

@ -131,8 +131,8 @@ extern afs_rwlock_t afs_xcbhash;
* times we go back and forth from caching to bypass.
*/
void
afs_TransitionToBypass(register struct vcache *avc,
register afs_ucred_t *acred, int aflags)
afs_TransitionToBypass(struct vcache *avc,
afs_ucred_t *acred, int aflags)
{
afs_int32 code;
@ -210,8 +210,8 @@ done:
* the number of times we go back and forth from caching to bypass.
*/
void
afs_TransitionToCaching(register struct vcache *avc,
register afs_ucred_t *acred,
afs_TransitionToCaching(struct vcache *avc,
afs_ucred_t *acred,
int aflags)
{
int resetDesire = 0;
@ -301,9 +301,9 @@ afs_TransitionToCaching(register struct vcache *avc,
/* no-cache prefetch routine */
static afs_int32
afs_NoCacheFetchProc(register struct rx_call *acall,
register struct vcache *avc,
register uio_t *auio,
afs_NoCacheFetchProc(struct rx_call *acall,
struct vcache *avc,
uio_t *auio,
afs_int32 release_pages,
afs_int32 size)
{
@ -464,8 +464,8 @@ done:
/* dispatch a no-cache read request */
afs_int32
afs_ReadNoCache(register struct vcache *avc,
register struct nocache_read_request *bparms,
afs_ReadNoCache(struct vcache *avc,
struct nocache_read_request *bparms,
afs_ucred_t *acred)
{
afs_int32 code;
@ -542,9 +542,9 @@ cleanup:
/* Cannot have static linkage--called from BPrefetch (afs_daemons) */
afs_int32
afs_PrefetchNoCache(register struct vcache *avc,
register afs_ucred_t *acred,
register struct nocache_read_request *bparms)
afs_PrefetchNoCache(struct vcache *avc,
afs_ucred_t *acred,
struct nocache_read_request *bparms)
{
uio_t *auio;
struct iovec *iovecp;
@ -554,7 +554,7 @@ afs_PrefetchNoCache(register struct vcache *avc,
afs_int32 length_hi, bytes, locked;
#endif
register struct afs_conn *tc;
struct afs_conn *tc;
afs_int32 i;
struct rx_call *tcall;
struct tlocal1 {

8
src/afs/afs_bypasscache.h
View File

@ -112,8 +112,8 @@ extern int cache_bypass_prefetch;
extern int cache_bypass_strategy;
extern int cache_bypass_threshold;
void afs_TransitionToBypass(register struct vcache *, register afs_ucred_t *, int);
void afs_TransitionToCaching(register struct vcache *, register afs_ucred_t *, int);
void afs_TransitionToBypass(struct vcache *, afs_ucred_t *, int);
void afs_TransitionToCaching(struct vcache *, afs_ucred_t *, int);
/* Cache strategy permits vnode transition between caching and no-cache--
* currently, this means LARGE_FILES_BYPASS_CACHE. Currently, no pioctl permits
@ -139,12 +139,12 @@ void afs_TransitionToCaching(register struct vcache *, register afs_ucred_t *, i
/* dispatch a no-cache read request */
afs_int32
afs_ReadNoCache(register struct vcache *avc, register struct nocache_read_request *bparms,
afs_ReadNoCache(struct vcache *avc, struct nocache_read_request *bparms,
afs_ucred_t *acred);
/* no-cache prefetch routine */
afs_int32
afs_PrefetchNoCache(register struct vcache *avc, register afs_ucred_t *acred,
afs_PrefetchNoCache(struct vcache *avc, afs_ucred_t *acred,
struct nocache_read_request *bparms);

2
src/afs/afs_call.c
View File

@ -1194,7 +1194,7 @@ afs_syscall_call(long parm, long parm2, long parm3,
int
afs_CheckInit(void)
{
register int code = 0;
int code = 0;
AFS_STATCNT(afs_CheckInit);
if (afs_initState <= 100)

40
src/afs/afs_callback.c
View File

@ -101,8 +101,8 @@ SRXAFSCB_GetCE(struct rx_call *a_call, afs_int32 a_index,
struct AFSDBCacheEntry *a_result)
{
register int i; /*Loop variable */
register struct vcache *tvc; /*Ptr to current cache entry */
int i; /*Loop variable */
struct vcache *tvc; /*Ptr to current cache entry */
int code; /*Return code */
XSTATS_DECLS;
@ -187,8 +187,8 @@ int
SRXAFSCB_GetCE64(struct rx_call *a_call, afs_int32 a_index,
struct AFSDBCacheEntry64 *a_result)
{
register int i; /*Loop variable */
register struct vcache *tvc; /*Ptr to current cache entry */
int i; /*Loop variable */
struct vcache *tvc; /*Ptr to current cache entry */
int code; /*Return code */
XSTATS_DECLS;
@ -404,11 +404,11 @@ Appears to need to be called with GLOCK held, as the icl_Event4 stuff asserts ot
*------------------------------------------------------------------------*/
static int
ClearCallBack(register struct rx_connection *a_conn,
register struct AFSFid *a_fid)
ClearCallBack(struct rx_connection *a_conn,
struct AFSFid *a_fid)
{
register struct vcache *tvc;
register int i;
struct vcache *tvc;
int i;
struct VenusFid localFid;
struct volume *tv;
#ifdef AFS_DARWIN80_ENV
@ -637,12 +637,12 @@ loop2:
*------------------------------------------------------------------------*/
int
SRXAFSCB_CallBack(struct rx_call *a_call, register struct AFSCBFids *a_fids,
SRXAFSCB_CallBack(struct rx_call *a_call, struct AFSCBFids *a_fids,
struct AFSCBs *a_callbacks)
{
register int i; /*Loop variable */
int i; /*Loop variable */
struct AFSFid *tfid; /*Ptr to current fid */
register struct rx_connection *tconn; /*Call's connection */
struct rx_connection *tconn; /*Call's connection */
int code = 0;
XSTATS_DECLS;
@ -734,10 +734,10 @@ SRXAFSCB_Probe(struct rx_call *a_call)
int
SRXAFSCB_InitCallBackState(struct rx_call *a_call)
{
register int i;
register struct vcache *tvc;
register struct rx_connection *tconn;
register struct rx_peer *peer;
int i;
struct vcache *tvc;
struct rx_connection *tconn;
struct rx_peer *peer;
struct server *ts;
int code = 0;
XSTATS_DECLS;
@ -780,8 +780,8 @@ SRXAFSCB_InitCallBackState(struct rx_call *a_call)
/* find any volumes residing on this server and flush their state */
{
register struct volume *tv;
register int j;
struct volume *tv;
int j;
for (i = 0; i < NVOLS; i++)
for (tv = afs_volumes[i]; tv; tv = tv->next) {
@ -875,7 +875,7 @@ SRXAFSCB_GetXStats(struct rx_call *a_call, afs_int32 a_clientVersionNum,
afs_int32 a_collectionNumber, afs_int32 * a_srvVersionNumP,
afs_int32 * a_timeP, AFSCB_CollData * a_dataP)
{
register int code; /*Return value */
int code; /*Return value */
afs_int32 *dataBuffP; /*Ptr to data to be returned */
afs_int32 dataBytes; /*Bytes in data buffer */
XSTATS_DECLS;
@ -1736,8 +1736,8 @@ SRXAFSCB_GetDE(struct rx_call *a_call, afs_int32 a_index, afs_int32 *addr,
{ /*SRXAFSCB_GetDE*/
int code = 0; /*Return code*/
#if 0 && defined(AFS_LINUX24_ENV)
register int i; /*Loop variable*/
register struct vcache *tvc = afs_globalVp;
int i; /*Loop variable*/
struct vcache *tvc = afs_globalVp;
struct dentry *dentry;
struct list_head *cur, *head = &(AFSTOI(tvc))->i_dentry;

14
src/afs/afs_cbqueue.c
View File

@ -188,11 +188,11 @@ void
afs_CheckCallbacks(unsigned int secs)
{
struct vcache *tvc;
register struct afs_q *tq;
struct afs_q *tq;
struct afs_q *uq;
afs_uint32 now;
struct volume *tvp;
register int safety;
int safety;
ObtainWriteLock(&afs_xcbhash, 85); /* pretty likely I'm going to remove something */
now = osi_Time();
@ -296,8 +296,8 @@ afs_CheckCallbacks(unsigned int secs)
void
afs_FlushCBs(void)
{
register int i;
register struct vcache *tvc;
int i;
struct vcache *tvc;
ObtainWriteLock(&afs_xcbhash, 86); /* pretty likely I'm going to remove something */
@ -326,8 +326,8 @@ afs_FlushCBs(void)
void
afs_FlushServerCBs(struct server *srvp)
{
register int i;
register struct vcache *tvc;
int i;
struct vcache *tvc;
ObtainWriteLock(&afs_xcbhash, 86); /* pretty likely I'm going to remove something */
@ -356,7 +356,7 @@ afs_FlushServerCBs(struct server *srvp)
void
afs_InitCBQueue(int doLockInit)
{
register int i;
int i;
memset(cbHashT, 0, CBHTSIZE * sizeof(struct bucket));
for (i = 0; i < CBHTSIZE; i++) {

10
src/afs/afs_chunkops.h
View File

@ -58,15 +58,15 @@ struct afs_cacheOps {
int (*fwrite) (struct osi_file * fp, afs_int32 offset, void *buf,
afs_int32 len);
int (*close) (struct osi_file * fp);
int (*vread) (register struct vcache * avc, struct uio * auio,
int (*vread) (struct vcache * avc, struct uio * auio,
afs_ucred_t * acred, daddr_t albn, struct buf ** abpp,
int noLock);
int (*vwrite) (register struct vcache * avc, struct uio * auio, int aio,
int (*vwrite) (struct vcache * avc, struct uio * auio, int aio,
afs_ucred_t * acred, int noLock);
struct dcache *(*GetDSlot) (register afs_int32 aslot,
register struct dcache * tmpdc);
struct dcache *(*GetDSlot) (afs_int32 aslot,
struct dcache * tmpdc);
struct volume *(*GetVolSlot) (void);
int (*HandleLink) (register struct vcache * avc, struct vrequest * areq);
int (*HandleLink) (struct vcache * avc, struct vrequest * areq);
};
/* Ideally we should have used consistent naming - like COP_OPEN, COP_TRUNCATE, etc. */

12
src/afs/afs_conn.c
View File

@ -100,7 +100,7 @@ afs_pickSecurityObject(struct afs_conn *conn, int *secLevel)
* @return The conn struct, or NULL.
*/
struct afs_conn *
afs_Conn(register struct VenusFid *afid, register struct vrequest *areq,
afs_Conn(struct VenusFid *afid, struct vrequest *areq,
afs_int32 locktype)
{
u_short fsport = AFS_FSPORT;
@ -393,12 +393,12 @@ afs_ConnByHost(struct server *aserver, unsigned short aport, afs_int32 acell,
*/
struct afs_conn *
afs_ConnByMHosts(struct server *ahosts[], unsigned short aport,
afs_int32 acell, register struct vrequest *areq,
afs_int32 acell, struct vrequest *areq,
afs_int32 locktype)
{
register afs_int32 i;
register struct afs_conn *tconn;
register struct server *ts;
afs_int32 i;
struct afs_conn *tconn;
struct server *ts;
/* try to find any connection from the set */
AFS_STATCNT(afs_ConnByMHosts);
@ -421,7 +421,7 @@ afs_ConnByMHosts(struct server *ahosts[], unsigned short aport,
* @param locktype
*/
void
afs_PutConn(register struct afs_conn *ac, afs_int32 locktype)
afs_PutConn(struct afs_conn *ac, afs_int32 locktype)
{
AFS_STATCNT(afs_PutConn);
ac->refCount--;

26
src/afs/afs_daemons.c
View File

@ -437,9 +437,9 @@ afs_CheckRootVolume(void)
/* ptr_parm 0 is the pathname, size_parm 0 to the fetch is the chunk number */
static void
BPath(register struct brequest *ab)
BPath(struct brequest *ab)
{
register struct dcache *tdc = NULL;
struct dcache *tdc = NULL;
struct vcache *tvc = NULL;
struct vnode *tvn = NULL;
#ifdef AFS_LINUX22_ENV
@ -494,10 +494,10 @@ BPath(register struct brequest *ab)
* size_parm 1 is true iff we should release the dcache entry here.
*/
static void
BPrefetch(register struct brequest *ab)
BPrefetch(struct brequest *ab)
{
register struct dcache *tdc;
register struct vcache *tvc;
struct dcache *tdc;
struct vcache *tvc;
afs_size_t offset, len, abyte, totallen = 0;
struct vrequest treq;
@ -535,7 +535,7 @@ BPrefetch(register struct brequest *ab)
#if defined(AFS_CACHE_BYPASS)
static void
BPrefetchNoCache(register struct brequest *ab)
BPrefetchNoCache(struct brequest *ab)
{
struct vrequest treq;
afs_size_t len;
@ -551,10 +551,10 @@ BPrefetchNoCache(register struct brequest *ab)
#endif
static void
BStore(register struct brequest *ab)
BStore(struct brequest *ab)
{
register struct vcache *tvc;
register afs_int32 code;
struct vcache *tvc;
afs_int32 code;
struct vrequest treq;
#if defined(AFS_SGI_ENV)
struct cred *tmpcred;
@ -601,7 +601,7 @@ BStore(register struct brequest *ab)
/* release a held request buffer */
void
afs_BRelease(register struct brequest *ab)
afs_BRelease(struct brequest *ab)
{
AFS_STATCNT(afs_BRelease);
@ -625,13 +625,13 @@ afs_BBusy(void)
}
struct brequest *
afs_BQueue(register short aopcode, register struct vcache *avc,
afs_BQueue(short aopcode, struct vcache *avc,
afs_int32 dontwait, afs_int32 ause, afs_ucred_t *acred,
afs_size_t asparm0, afs_size_t asparm1, void *apparm0,
void *apparm1, void *apparm2)
{
register int i;
register struct brequest *tb;
int i;
struct brequest *tb;
AFS_STATCNT(afs_BQueue);
ObtainWriteLock(&afs_xbrs, 296);

84
src/afs/afs_dcache.c
View File

@ -309,8 +309,8 @@ afs_DCWhichBucket(afs_int32 phase, afs_int32 bucket)
*/
void
afs_StoreWarn(register afs_int32 acode, afs_int32 avolume,
register afs_int32 aflags)
afs_StoreWarn(afs_int32 acode, afs_int32 avolume,
afs_int32 aflags)
{
static char problem_fmt[] =
"afs: failed to store file in volume %d (%s)\n";
@ -500,9 +500,9 @@ afs_CacheTruncateDaemon(void)
*/
void
afs_AdjustSize(register struct dcache *adc, register afs_int32 newSize)
afs_AdjustSize(struct dcache *adc, afs_int32 newSize)
{
register afs_int32 oldSize;
afs_int32 oldSize;
AFS_STATCNT(afs_AdjustSize);
@ -555,7 +555,7 @@ afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint)
afs_int32 i, j;
afs_hyper_t vtime;
int skip, phase;
register struct vcache *tvc;
struct vcache *tvc;
afs_uint32 victims[MAXATONCE];
struct dcache *victimDCs[MAXATONCE];
afs_hyper_t victimTimes[MAXATONCE]; /* youngest (largest LRU time) first */
@ -957,7 +957,7 @@ afs_HashOutDCache(struct dcache *adc, int zap)
* (in write mode).
*/
void
afs_FlushDCache(register struct dcache *adc)
afs_FlushDCache(struct dcache *adc)
{
AFS_STATCNT(afs_FlushDCache);
/*
@ -998,7 +998,7 @@ afs_FlushDCache(register struct dcache *adc)
* \note Environment: called with afs_xdcache lock write-locked.
*/
static void
afs_FreeDCache(register struct dcache *adc)
afs_FreeDCache(struct dcache *adc)
{
/* Thread on free list, update free list count and mark entry as
* freed in its indexFlags element. Also, ensure DCache entry gets
@ -1037,9 +1037,9 @@ afs_FreeDCache(register struct dcache *adc)
*/
static void
afs_DiscardDCache(register struct dcache *adc)
afs_DiscardDCache(struct dcache *adc)
{
register afs_int32 size;
afs_int32 size;
AFS_STATCNT(afs_DiscardDCache);
@ -1073,9 +1073,9 @@ afs_DiscardDCache(register struct dcache *adc)
static void
afs_FreeDiscardedDCache(void)
{
register struct dcache *tdc;
register struct osi_file *tfile;
register afs_int32 size;
struct dcache *tdc;
struct osi_file *tfile;
afs_int32 size;
AFS_STATCNT(afs_FreeDiscardedDCache);
@ -1260,7 +1260,7 @@ afs_RefDCache(struct dcache *adc)
* Nothing interesting.
*/
int
afs_PutDCache(register struct dcache *adc)
afs_PutDCache(struct dcache *adc)
{
AFS_STATCNT(afs_PutDCache);
ObtainWriteLock(&adc->tlock, 276);
@ -1286,11 +1286,11 @@ afs_PutDCache(register struct dcache *adc)
* Both pvnLock and lock are write held.
*/
void
afs_TryToSmush(register struct vcache *avc, afs_ucred_t *acred, int sync)
afs_TryToSmush(struct vcache *avc, afs_ucred_t *acred, int sync)
{
register struct dcache *tdc;
register int index;
register int i;
struct dcache *tdc;
int index;
int i;
AFS_STATCNT(afs_TryToSmush);
afs_Trace2(afs_iclSetp, CM_TRACE_TRYTOSMUSH, ICL_TYPE_POINTER, avc,
ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
@ -1439,11 +1439,11 @@ afs_DCacheMissingChunks(struct vcache *avc)
*/
struct dcache *
afs_FindDCache(register struct vcache *avc, afs_size_t abyte)
afs_FindDCache(struct vcache *avc, afs_size_t abyte)
{
afs_int32 chunk;
register afs_int32 i, index;
register struct dcache *tdc = NULL;
afs_int32 i, index;
struct dcache *tdc = NULL;
AFS_STATCNT(afs_FindDCache);
chunk = AFS_CHUNK(abyte);
@ -1618,13 +1618,13 @@ updateV2DC(int lockVc, struct vcache *v, struct dcache *d, int src)
/* avc - Write-locked unless aflags & 1 */
struct dcache *
afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
register struct vrequest *areq, afs_size_t * aoffset,
afs_GetDCache(struct vcache *avc, afs_size_t abyte,
struct vrequest *areq, afs_size_t * aoffset,
afs_size_t * alen, int aflags)
{
register afs_int32 i, code, shortcut;
afs_int32 i, code, shortcut;
#if defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV)
register afs_int32 adjustsize = 0;
afs_int32 adjustsize = 0;
#endif
int setLocks;
afs_int32 index;
@ -1634,9 +1634,9 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
afs_size_t Position = 0;
afs_int32 size, tlen; /* size of segment to transfer */
struct afs_FetchOutput *tsmall = 0;
register struct dcache *tdc;
register struct osi_file *file;
register struct afs_conn *tc;
struct dcache *tdc;
struct osi_file *file;
struct afs_conn *tc;
int downDCount = 0;
struct server *newCallback = NULL;
char setNewCallback;
@ -2477,8 +2477,8 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
void
afs_WriteThroughDSlots(void)
{
register struct dcache *tdc;
register afs_int32 i, touchedit = 0;
struct dcache *tdc;
afs_int32 i, touchedit = 0;
struct afs_q DirtyQ, *tq;
@ -2570,9 +2570,9 @@ afs_WriteThroughDSlots(void)
*/
struct dcache *
afs_MemGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
afs_MemGetDSlot(afs_int32 aslot, struct dcache *tmpdc)
{
register struct dcache *tdc;
struct dcache *tdc;
int existing = 0;
AFS_STATCNT(afs_MemGetDSlot);
@ -2660,10 +2660,10 @@ unsigned int last_error = 0, lasterrtime = 0;
* afs_xdcache lock write-locked.
*/
struct dcache *
afs_UFSGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
afs_UFSGetDSlot(afs_int32 aslot, struct dcache *tmpdc)
{
register afs_int32 code;
register struct dcache *tdc;
afs_int32 code;
struct dcache *tdc;
int existing = 0;
int entryok;
@ -2794,9 +2794,9 @@ afs_UFSGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
*/
int
afs_WriteDCache(register struct dcache *adc, int atime)
afs_WriteDCache(struct dcache *adc, int atime)
{
register afs_int32 code;
afs_int32 code;
if (cacheDiskType == AFS_FCACHE_TYPE_MEM)
return 0;
@ -2830,10 +2830,10 @@ afs_WriteDCache(register struct dcache *adc, int atime)
* Nothing interesting.
*/
int
afs_wakeup(register struct vcache *avc)
afs_wakeup(struct vcache *avc)
{
register int i;
register struct brequest *tb;
int i;
struct brequest *tb;
tb = afs_brs;
AFS_STATCNT(afs_wakeup);
for (i = 0; i < NBRS; i++, tb++) {
@ -2878,12 +2878,12 @@ afs_wakeup(register struct vcache *avc)
int
afs_InitCacheFile(char *afile, ino_t ainode)
{
register afs_int32 code;
afs_int32 code;
afs_int32 index;
int fileIsBad;
struct osi_file *tfile;
struct osi_stat tstat;
register struct dcache *tdc;
struct dcache *tdc;
AFS_STATCNT(afs_InitCacheFile);
index = afs_stats_cmperf.cacheNumEntries;
@ -3016,7 +3016,7 @@ afs_InitCacheFile(char *afile, ino_t ainode)
void
afs_dcacheInit(int afiles, int ablocks, int aDentries, int achunk, int aflags)
{
register struct dcache *tdp;
struct dcache *tdp;
int i;
int code;

4
src/afs/afs_error.c
View File

@ -205,7 +205,7 @@ et_to_sys_error(afs_int32 in)
}
void
afs_CopyError(register struct vrequest *afrom, register struct vrequest *ato)
afs_CopyError(struct vrequest *afrom, struct vrequest *ato)
{
int i = 0;
AFS_STATCNT(afs_CopyError);
@ -232,7 +232,7 @@ afs_CopyError(register struct vrequest *afrom, register struct vrequest *ato)
}
void
afs_FinalizeReq(register struct vrequest *areq)
afs_FinalizeReq(struct vrequest *areq)
{
int i = 0;
AFS_STATCNT(afs_FinalizeReq);

1
src/afs/afs_fetchstore.c
View File

@ -19,7 +19,6 @@
#undef kmem_free
#undef mem_alloc
#undef mem_free
#undef register
#endif /* AFS_ALPHA_ENV */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* statistics */

84
src/afs/afs_icl.c
View File

@ -126,7 +126,7 @@ Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval)
#endif
{
afs_int32 *lp, elts, flags;
register afs_int32 code;
afs_int32 code;
struct afs_icl_log *logp;
struct afs_icl_set *setp;
#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
@ -397,12 +397,12 @@ afs_lock_t afs_icl_lock;
/* exported routine: a 4 parameter event */
int
afs_icl_Event4(register struct afs_icl_set *setp, afs_int32 eventID,
afs_icl_Event4(struct afs_icl_set *setp, afs_int32 eventID,
afs_int32 lAndT, long p1, long p2, long p3, long p4)
{
afs_int32 mask;
register int i;
register afs_int32 tmask;
int i;
afs_int32 tmask;
int ix;
/* If things aren't init'ed yet (or the set is inactive), don't panic */
@ -433,21 +433,21 @@ afs_icl_Event4(register struct afs_icl_set *setp, afs_int32 eventID,
* Otherwise, could call afs_icl_Event4 directly.
*/
int
afs_icl_Event3(register struct afs_icl_set *setp, afs_int32 eventID,
afs_icl_Event3(struct afs_icl_set *setp, afs_int32 eventID,
afs_int32 lAndT, long p1, long p2, long p3)
{
return afs_icl_Event4(setp, eventID, lAndT, p1, p2, p3, (long)0);
}
int
afs_icl_Event2(register struct afs_icl_set *setp, afs_int32 eventID,
afs_icl_Event2(struct afs_icl_set *setp, afs_int32 eventID,
afs_int32 lAndT, long p1, long p2)
{
return afs_icl_Event4(setp, eventID, lAndT, p1, p2, (long)0, (long)0);
}
int
afs_icl_Event1(register struct afs_icl_set *setp, afs_int32 eventID,
afs_icl_Event1(struct afs_icl_set *setp, afs_int32 eventID,
afs_int32 lAndT, long p1)
{
return afs_icl_Event4(setp, eventID, lAndT, p1, (long)0, (long)0,
@ -455,7 +455,7 @@ afs_icl_Event1(register struct afs_icl_set *setp, afs_int32 eventID,
}
int
afs_icl_Event0(register struct afs_icl_set *setp, afs_int32 eventID,
afs_icl_Event0(struct afs_icl_set *setp, afs_int32 eventID,
afs_int32 lAndT)
{
return afs_icl_Event4(setp, eventID, lAndT, (long)0, (long)0, (long)0,
@ -471,9 +471,9 @@ struct afs_icl_log *afs_icl_allLogs = 0;
* Log must be write-locked.
*/
static void
afs_icl_GetLogSpace(register struct afs_icl_log *logp, afs_int32 minSpace)
afs_icl_GetLogSpace(struct afs_icl_log *logp, afs_int32 minSpace)
{
register unsigned int tsize;
unsigned int tsize;
while (logp->logSize - logp->logElements <= minSpace) {
/* eat a record */
@ -496,7 +496,7 @@ afs_icl_AppendString(struct afs_icl_log *logp, char *astr)
{
char *op; /* ptr to char to write */
int tc;
register int bib; /* bytes in buffer */
int bib; /* bytes in buffer */
bib = 0;
op = (char *)&(logp->datap[logp->firstFree]);
@ -609,11 +609,11 @@ afs_icl_AppendOne(struct afs_icl_log *logp, int type, long parm)
*/
void
afs_icl_AppendRecord(register struct afs_icl_log *logp, afs_int32 op,
afs_icl_AppendRecord(struct afs_icl_log *logp, afs_int32 op,
afs_int32 types, long p1, long p2, long p3, long p4)
{
int rsize; /* record size in longs */
register int tsize; /* temp size */
int tsize; /* temp size */
osi_timeval_t tv;
int t1, t2, t3, t4;
@ -724,7 +724,7 @@ int
afs_icl_CreateLogWithFlags(char *name, afs_int32 logSize, afs_uint32 flags,
struct afs_icl_log **outLogpp)
{
register struct afs_icl_log *logp;
struct afs_icl_log *logp;
/* add into global list under lock */
ObtainWriteLock(&afs_icl_lock, 183);
@ -775,7 +775,7 @@ afs_icl_CreateLogWithFlags(char *name, afs_int32 logSize, afs_uint32 flags,
* find the record with cookie value cookie.
*/
int
afs_icl_CopyOut(register struct afs_icl_log *logp, afs_int32 * bufferp,
afs_icl_CopyOut(struct afs_icl_log *logp, afs_int32 * bufferp,
afs_int32 * bufSizep, afs_uint32 * cookiep,
afs_int32 * flagsp)
{
@ -905,7 +905,7 @@ afs_icl_GetLogParms(struct afs_icl_log *logp, afs_int32 * maxSizep,
/* hold and release logs */
int
afs_icl_LogHold(register struct afs_icl_log *logp)
afs_icl_LogHold(struct afs_icl_log *logp)
{
ObtainWriteLock(&afs_icl_lock, 187);
logp->refCount++;
@ -915,7 +915,7 @@ afs_icl_LogHold(register struct afs_icl_log *logp)
/* hold and release logs, called with lock already held */
int
afs_icl_LogHoldNL(register struct afs_icl_log *logp)
afs_icl_LogHoldNL(struct afs_icl_log *logp)
{
logp->refCount++;
return 0;
@ -923,7 +923,7 @@ afs_icl_LogHoldNL(register struct afs_icl_log *logp)
/* keep track of how many sets believe the log itself is allocated */
int
afs_icl_LogUse(register struct afs_icl_log *logp)
afs_icl_LogUse(struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock, 188);
if (logp->setCount == 0) {
@ -945,7 +945,7 @@ afs_icl_LogUse(register struct afs_icl_log *logp)
/* decrement the number of real users of the log, free if possible */
int
afs_icl_LogFreeUse(register struct afs_icl_log *logp)
afs_icl_LogFreeUse(struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock, 189);
if (--logp->setCount == 0) {
@ -964,7 +964,7 @@ afs_icl_LogFreeUse(register struct afs_icl_log *logp)
/* set the size of the log to 'logSize' */
int
afs_icl_LogSetSize(register struct afs_icl_log *logp, afs_int32 logSize)
afs_icl_LogSetSize(struct afs_icl_log *logp, afs_int32 logSize)
{
ObtainWriteLock(&logp->lock, 190);
if (!logp->datap) {
@ -994,9 +994,9 @@ afs_icl_LogSetSize(register struct afs_icl_log *logp, afs_int32 logSize)
/* free a log. Called with afs_icl_lock locked. */
int
afs_icl_ZapLog(register struct afs_icl_log *logp)
afs_icl_ZapLog(struct afs_icl_log *logp)
{
register struct afs_icl_log **lpp, *tp;
struct afs_icl_log **lpp, *tp;
for (lpp = &afs_icl_allLogs, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
if (tp == logp) {
@ -1016,7 +1016,7 @@ afs_icl_ZapLog(register struct afs_icl_log *logp)
/* do the release, watching for deleted entries */
int
afs_icl_LogRele(register struct afs_icl_log *logp)
afs_icl_LogRele(struct afs_icl_log *logp)
{
ObtainWriteLock(&afs_icl_lock, 191);
if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
@ -1028,7 +1028,7 @@ afs_icl_LogRele(register struct afs_icl_log *logp)
/* do the release, watching for deleted entries, log already held */
int
afs_icl_LogReleNL(register struct afs_icl_log *logp)
afs_icl_LogReleNL(struct afs_icl_log *logp)
{
if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
afs_icl_ZapLog(logp); /* destroys logp's lock! */
@ -1038,7 +1038,7 @@ afs_icl_LogReleNL(register struct afs_icl_log *logp)
/* zero out the log */
int
afs_icl_ZeroLog(register struct afs_icl_log *logp)
afs_icl_ZeroLog(struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock, 192);
logp->firstUsed = logp->firstFree = 0;
@ -1050,7 +1050,7 @@ afs_icl_ZeroLog(register struct afs_icl_log *logp)
/* free a log entry, and drop its reference count */
int
afs_icl_LogFree(register struct afs_icl_log *logp)
afs_icl_LogFree(struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock, 193);
logp->states |= ICL_LOGF_DELETED;
@ -1063,7 +1063,7 @@ afs_icl_LogFree(register struct afs_icl_log *logp)
struct afs_icl_log *
afs_icl_FindLog(char *name)
{
register struct afs_icl_log *tp;
struct afs_icl_log *tp;
ObtainWriteLock(&afs_icl_lock, 194);
for (tp = afs_icl_allLogs; tp; tp = tp->nextp) {
if (strcmp(tp->name, name) == 0) {
@ -1081,8 +1081,8 @@ afs_icl_EnumerateLogs(int (*aproc)
(char *name, char *arock, struct afs_icl_log * tp),
char *arock)
{
register struct afs_icl_log *tp;
register afs_int32 code;
struct afs_icl_log *tp;
afs_int32 code;
code = 0;
ObtainWriteLock(&afs_icl_lock, 195);
@ -1124,8 +1124,8 @@ afs_icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
struct afs_icl_log *fatalLogp, afs_uint32 flags,
struct afs_icl_set **outSetpp)
{
register struct afs_icl_set *setp;
register int i;
struct afs_icl_set *setp;
int i;
afs_int32 states = ICL_DEFAULT_SET_STATES;
ObtainWriteLock(&afs_icl_lock, 197);
@ -1243,7 +1243,7 @@ afs_icl_GetEnable(struct afs_icl_set *setp, afs_int32 eventID, int *getValuep)
/* hold and release event sets */
int
afs_icl_SetHold(register struct afs_icl_set *setp)
afs_icl_SetHold(struct afs_icl_set *setp)
{
ObtainWriteLock(&afs_icl_lock, 201);
setp->refCount++;
@ -1253,11 +1253,11 @@ afs_icl_SetHold(register struct afs_icl_set *setp)
/* free a set. Called with afs_icl_lock locked */
int
afs_icl_ZapSet(register struct afs_icl_set *setp)
afs_icl_ZapSet(struct afs_icl_set *setp)
{
register struct afs_icl_set **lpp, *tp;
struct afs_icl_set **lpp, *tp;
int i;
register struct afs_icl_log *tlp;
struct afs_icl_log *tlp;
for (lpp = &afs_icl_allSets, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
if (tp == setp) {
@ -1281,7 +1281,7 @@ afs_icl_ZapSet(register struct afs_icl_set *setp)
/* do the release, watching for deleted entries */
int
afs_icl_SetRele(register struct afs_icl_set *setp)
afs_icl_SetRele(struct afs_icl_set *setp)
{
ObtainWriteLock(&afs_icl_lock, 202);
if (--setp->refCount == 0 && (setp->states & ICL_SETF_DELETED)) {
@ -1293,7 +1293,7 @@ afs_icl_SetRele(register struct afs_icl_set *setp)
/* free a set entry, dropping its reference count */
int
afs_icl_SetFree(register struct afs_icl_set *setp)
afs_icl_SetFree(struct afs_icl_set *setp)
{
ObtainWriteLock(&setp->lock, 203);
setp->states |= ICL_SETF_DELETED;
@ -1306,7 +1306,7 @@ afs_icl_SetFree(register struct afs_icl_set *setp)
struct afs_icl_set *
afs_icl_FindSet(char *name)
{
register struct afs_icl_set *tp;
struct afs_icl_set *tp;
ObtainWriteLock(&afs_icl_lock, 204);
for (tp = afs_icl_allSets; tp; tp = tp->nextp) {
if (strcmp(tp->name, name) == 0) {
@ -1323,7 +1323,7 @@ afs_icl_FindSet(char *name)
int
afs_icl_ZeroSet(struct afs_icl_set *setp)
{
register int i;
int i;
int code = 0;
int tcode;
struct afs_icl_log *logp;
@ -1348,8 +1348,8 @@ afs_icl_EnumerateSets(int (*aproc)
(char *name, char *arock, struct afs_icl_log * tp),
char *arock)
{
register struct afs_icl_set *tp, *np;
register afs_int32 code;
struct afs_icl_set *tp, *np;
afs_int32 code;
code = 0;
ObtainWriteLock(&afs_icl_lock, 205);
@ -1371,7 +1371,7 @@ afs_icl_EnumerateSets(int (*aproc)
int
afs_icl_AddLogToSet(struct afs_icl_set *setp, struct afs_icl_log *newlogp)
{
register int i;
int i;
int code = -1;
ObtainWriteLock(&setp->lock, 207);

14
src/afs/afs_init.c
View File

@ -100,8 +100,8 @@ afs_CacheInit(afs_int32 astatSize, afs_int32 afiles, afs_int32 ablocks,
afs_int32 aflags, afs_int32 ninodes, afs_int32 nusers,
afs_int32 dynamic_vcaches)
{
register afs_int32 i;
register struct volume *tv;
afs_int32 i;
struct volume *tv;
AFS_STATCNT(afs_CacheInit);
/*
@ -208,7 +208,7 @@ afs_CacheInit(afs_int32 astatSize, afs_int32 afiles, afs_int32 ablocks,
void
afs_ComputeCacheParms(void)
{
register afs_int32 i;
afs_int32 i;
afs_int32 afs_maxCacheDirty;
/*
@ -360,11 +360,11 @@ afs_InitVolumeInfo(char *afile)
*
*/
int
afs_InitCacheInfo(register char *afile)
afs_InitCacheInfo(char *afile)
{
register afs_int32 code;
afs_int32 code;
struct osi_stat tstat;
register struct osi_file *tfile;
struct osi_file *tfile;
struct afs_fheader theader;
#ifndef AFS_LINUX22_ENV
struct vnode *filevp;
@ -511,7 +511,7 @@ int afs_resourceinit_flag = 0;
int
afs_ResourceInit(int preallocs)
{
register afs_int32 i;
afs_int32 i;
static struct rx_securityClass *secobj;
AFS_STATCNT(afs_ResourceInit);

20
src/afs/afs_lock.c
View File

@ -37,7 +37,7 @@ void Lock_ReleaseR(struct afs_lock *lock);
void Lock_ReleaseW(struct afs_lock *lock);
void
Lock_Init(register struct afs_lock *lock)
Lock_Init(struct afs_lock *lock)
{
AFS_STATCNT(Lock_Init);
@ -55,7 +55,7 @@ Lock_Init(register struct afs_lock *lock)
}
void
ObtainLock(register struct afs_lock *lock, int how,
ObtainLock(struct afs_lock *lock, int how,
unsigned int src_indicator)
{
switch (how) {
@ -92,7 +92,7 @@ ObtainLock(register struct afs_lock *lock, int how,
}
void
ReleaseLock(register struct afs_lock *lock, int how)
ReleaseLock(struct afs_lock *lock, int how)
{
if (how == READ_LOCK) {
if (!--lock->readers_reading && lock->wait_states) {
@ -120,7 +120,7 @@ ReleaseLock(register struct afs_lock *lock, int how)
}
void
Afs_Lock_Obtain(register struct afs_lock *lock, int how)
Afs_Lock_Obtain(struct afs_lock *lock, int how)
{
osi_timeval_t tt1, tt2, et;
afs_uint32 us;
@ -189,7 +189,7 @@ Afs_Lock_Obtain(register struct afs_lock *lock, int how)
/* release a lock, giving preference to new readers */
void
Afs_Lock_ReleaseR(register struct afs_lock *lock)
Afs_Lock_ReleaseR(struct afs_lock *lock)
{
AFS_STATCNT(Lock_ReleaseR);
AFS_ASSERT_GLOCK();
@ -204,7 +204,7 @@ Afs_Lock_ReleaseR(register struct afs_lock *lock)
/* release a lock, giving preference to new writers */
void
Afs_Lock_ReleaseW(register struct afs_lock *lock)
Afs_Lock_ReleaseW(struct afs_lock *lock)
{
AFS_STATCNT(Lock_ReleaseW);
AFS_ASSERT_GLOCK();
@ -219,7 +219,7 @@ Afs_Lock_ReleaseW(register struct afs_lock *lock)
/*
Wait for some change in the lock status.
void Lock_Wait(register struct afs_lock *lock)
void Lock_Wait(struct afs_lock *lock)
{
AFS_STATCNT(Lock_Wait);
if (lock->readers_reading || lock->excl_locked) return 1;
@ -235,7 +235,7 @@ void Lock_Wait(register struct afs_lock *lock)
/* release a write lock and sleep on an address, atomically */
void
afs_osi_SleepR(register char *addr, register struct afs_lock *alock)
afs_osi_SleepR(char *addr, struct afs_lock *alock)
{
AFS_STATCNT(osi_SleepR);
ReleaseReadLock(alock);
@ -244,7 +244,7 @@ afs_osi_SleepR(register char *addr, register struct afs_lock *alock)
/* release a write lock and sleep on an address, atomically */
void
afs_osi_SleepW(register char *addr, register struct afs_lock *alock)
afs_osi_SleepW(char *addr, struct afs_lock *alock)
{
AFS_STATCNT(osi_SleepW);
ReleaseWriteLock(alock);
@ -253,7 +253,7 @@ afs_osi_SleepW(register char *addr, register struct afs_lock *alock)
/* release a write lock and sleep on an address, atomically */
void
afs_osi_SleepS(register char *addr, register struct afs_lock *alock)
afs_osi_SleepS(char *addr, struct afs_lock *alock)
{
AFS_STATCNT(osi_SleepS);
ReleaseSharedLock(alock);

18
src/afs/afs_mariner.c
View File

@ -36,10 +36,10 @@ afs_int32 afs_mariner = 0;
afs_int32 afs_marinerHost = 0;
int
afs_AddMarinerName(register char *aname, register struct vcache *avc)
afs_AddMarinerName(char *aname, struct vcache *avc)
{
register int i;
register char *tp;
int i;
char *tp;
AFS_STATCNT(afs_AddMarinerName);
i = marinerPtr++;
@ -55,9 +55,9 @@ afs_AddMarinerName(register char *aname, register struct vcache *avc)
}
char *
afs_GetMariner(register struct vcache *avc)
afs_GetMariner(struct vcache *avc)
{
register int i;
int i;
AFS_STATCNT(afs_GetMariner);
for (i = 0; i < NMAR; i++) {
if (marinerVCs[i] == avc) {
@ -68,17 +68,17 @@ afs_GetMariner(register struct vcache *avc)
}
void
afs_MarinerLogFetch(register struct vcache *avc, register afs_int32 off,
register afs_int32 bytes, register afs_int32 idx)
afs_MarinerLogFetch(struct vcache *avc, afs_int32 off,
afs_int32 bytes, afs_int32 idx)
{
afs_MarinerLog("fetch$Fetching", avc);
} /*afs_MarinerLogFetch */
void
afs_MarinerLog(register char *astring, register struct vcache *avc)
afs_MarinerLog(char *astring, struct vcache *avc)
{
struct sockaddr_in taddr;
register char *tp, *tp1, *buf;
char *tp, *tp1, *buf;
struct iovec dvec;
AFS_STATCNT(afs_MarinerLog);

22
src/afs/afs_memcache.c
View File

@ -90,10 +90,10 @@ afs_MemCacheOpen(afs_dcache_id_t *ainode)
* this routine simulates a read in the Memory Cache
*/
int
afs_MemReadBlk(register struct osi_file *fP, int offset, void *dest,
afs_MemReadBlk(struct osi_file *fP, int offset, void *dest,
int size)
{
register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
int bytesRead;
ObtainReadLock(&mceP->afs_memLock);
@ -120,7 +120,7 @@ afs_MemReadBlk(register struct osi_file *fP, int offset, void *dest,
* this routine simulates a readv in the Memory Cache
*/
int
afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset,
afs_MemReadvBlk(struct memCacheEntry *mceP, int offset,
struct iovec *iov, int nio, int size)
{
int i;
@ -156,7 +156,7 @@ afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset,
int
afs_MemReadUIO(afs_dcache_id_t *ainode, struct uio *uioP)
{
register struct memCacheEntry *mceP =
struct memCacheEntry *mceP =
(struct memCacheEntry *)afs_MemCacheOpen(ainode);
int length = mceP->size - AFS_UIO_OFFSET(uioP);
afs_int32 code;
@ -170,10 +170,10 @@ afs_MemReadUIO(afs_dcache_id_t *ainode, struct uio *uioP)
}
int
afs_MemWriteBlk(register struct osi_file *fP, int offset, void *src,
afs_MemWriteBlk(struct osi_file *fP, int offset, void *src,
int size)
{
register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
struct iovec tiov;
tiov.iov_base = src;
@ -183,7 +183,7 @@ afs_MemWriteBlk(register struct osi_file *fP, int offset, void *src,
/*XXX: this extends a block arbitrarily to support big directories */
int
afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset,
afs_MemWritevBlk(struct memCacheEntry *mceP, int offset,
struct iovec *iov, int nio, int size)
{
int i;
@ -230,7 +230,7 @@ afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset,
int
afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP)
{
register struct memCacheEntry *mceP =
struct memCacheEntry *mceP =
(struct memCacheEntry *)afs_MemCacheOpen(ainode);
afs_int32 code;
@ -268,9 +268,9 @@ afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP)
}
int
afs_MemCacheTruncate(register struct osi_file *fP, int size)
afs_MemCacheTruncate(struct osi_file *fP, int size)
{
register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
AFS_STATCNT(afs_MemCacheTruncate);
ObtainWriteLock(&mceP->afs_memLock, 313);
@ -300,7 +300,7 @@ afs_MemCacheTruncate(register struct osi_file *fP, int size)
void
shutdown_memcache(void)
{
register int index;
int index;
if (cacheDiskType != AFS_FCACHE_TYPE_MEM)
return;

38
src/afs/afs_nfsclnt.c
View File

@ -47,10 +47,10 @@ extern struct afs_exporter *afs_nfsexporter;
/* Creates an nfsclientpag structure for the (uid, host) pair if one doesn't
* exist. RefCount is incremented and it's time stamped. */
static struct nfsclientpag *
afs_GetNfsClientPag(register afs_int32 uid, register afs_uint32 host)
afs_GetNfsClientPag(afs_int32 uid, afs_uint32 host)
{
register struct nfsclientpag *np;
register afs_int32 i, now;
struct nfsclientpag *np;
afs_int32 i, now;
#if defined(AFS_SGIMP_ENV)
osi_Assert(ISAFS_GLOCK());
@ -95,7 +95,7 @@ afs_GetNfsClientPag(register afs_int32 uid, register afs_uint32 host)
It's also called whenever a unixuser structure belonging to the remote user associated with the nfsclientpag structure, np, is garbage collected. */
void
afs_PutNfsClientPag(np)
register struct nfsclientpag *np;
struct nfsclientpag *np;
{
#if defined(AFS_SGIMP_ENV)
osi_Assert(ISAFS_GLOCK());
@ -111,8 +111,8 @@ afs_PutNfsClientPag(np)
static struct nfsclientpag *
afs_FindNfsClientPag(afs_int32 uid, afs_uint32 host, afs_int32 pag)
{
register struct nfsclientpag *np;
register afs_int32 i;
struct nfsclientpag *np;
afs_int32 i;
#if defined(AFS_SGIMP_ENV)
osi_Assert(ISAFS_GLOCK());
@ -178,9 +178,9 @@ afs_nfsclient_reqhandler(struct afs_exporter *exporter,
afs_uint32 host, afs_int32 *pagparam,
struct afs_exporter **outexporter)
{
register struct nfsclientpag *np, *tnp;
struct nfsclientpag *np, *tnp;
extern struct unixuser *afs_FindUser(), *afs_GetUser();
register struct unixuser *au = 0;
struct unixuser *au = 0;
afs_int32 uid, pag, code = 0;
AFS_ASSERT_GLOCK();
@ -417,7 +417,7 @@ done:
/* It's called whenever a new unixuser structure is created for the remote
* user associated with the nfsclientpag structure, np */
void
afs_nfsclient_hold(register struct nfsclientpag *np)
afs_nfsclient_hold(struct nfsclientpag *np)
{
#if defined(AFS_SGIMP_ENV)
osi_Assert(ISAFS_GLOCK());
@ -429,7 +429,7 @@ afs_nfsclient_hold(register struct nfsclientpag *np)
/* check if this exporter corresponds to the specified host */
int
afs_nfsclient_checkhost(register struct nfsclientpag *np, afs_uint32 host)
afs_nfsclient_checkhost(struct nfsclientpag *np, afs_uint32 host)
{
if (np->type != EXP_NFS)
return 0;
@ -439,7 +439,7 @@ afs_nfsclient_checkhost(register struct nfsclientpag *np, afs_uint32 host)
/* get the host for this exporter, or 0 if there is an error */
afs_uint32
afs_nfsclient_gethost(register struct nfsclientpag *np)
afs_nfsclient_gethost(struct nfsclientpag *np)
{
if (np->type != EXP_NFS)
return 0;
@ -451,11 +451,11 @@ afs_nfsclient_gethost(register struct nfsclientpag *np)
* user (inname contains the new sysname). In all cases, outname returns
* the current sysname value for this remote user */
int
afs_nfsclient_sysname(register struct nfsclientpag *np, char *inname,
afs_nfsclient_sysname(struct nfsclientpag *np, char *inname,
char ***outname, int *num, int allpags)
{
register struct nfsclientpag *tnp;
register afs_int32 i;
struct nfsclientpag *tnp;
afs_int32 i;
char *cp;
int count, t;
#if defined(AFS_SGIMP_ENV)
@ -506,11 +506,11 @@ afs_nfsclient_sysname(register struct nfsclientpag *np, char *inname,
* "unixuser" structures associated with them (i.e. unixusercnt == 0) and
* they haven't had any activity the last NFSCLIENTGC seconds */
void
afs_nfsclient_GC(register struct afs_exporter *exporter,
register afs_int32 pag)
afs_nfsclient_GC(struct afs_exporter *exporter,
afs_int32 pag)
{
register struct nfsclientpag *np, **tnp, *nnp;
register afs_int32 i, delflag;
struct nfsclientpag *np, **tnp, *nnp;
afs_int32 i, delflag;
int count;
#if defined(AFS_SGIMP_ENV)
@ -541,7 +541,7 @@ afs_nfsclient_GC(register struct afs_exporter *exporter,
int
afs_nfsclient_stats(register struct afs_exporter *export)
afs_nfsclient_stats(struct afs_exporter *export)
{
/* Nothing much to do here yet since most important stats are collected
* directly in the afs_exporter structure itself */

2
src/afs/afs_nfsdisp.c
View File

@ -310,7 +310,7 @@ afs_nfs2_dispatcher(int type, afs_int32 which, char *argp,
void
afs_nfs2_smallfidder(struct nfsdiropres *dr)
{
register fhandle_t *fhp = (fhandle_t *) & dr->dr_fhandle;
fhandle_t *fhp = (fhandle_t *) & dr->dr_fhandle;
afs_int32 addr[2];
struct vcache *vcp;

4
src/afs/afs_osi.c
View File

@ -238,7 +238,7 @@ afs_osi_SetTime(osi_timeval_t * atv)
/* drop the setting of the clock for now. spl7 is not
* known on hpux11.22
*/
register ulong_t s;
ulong_t s;
struct timeval t;
t.tv_sec = atv->tv_sec;
t.tv_usec = atv->tv_usec;
@ -250,7 +250,7 @@ afs_osi_SetTime(osi_timeval_t * atv)
}
#else
{
register int s;
int s;
s = splclock();
time = *atv;
(void)splx(s);

12
src/afs/afs_osi_alloc.c
View File

@ -45,8 +45,8 @@ void *
afs_osi_Alloc(size_t x)
{
#if !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
register struct osimem *tm = NULL;
register int size;
struct osimem *tm = NULL;
int size;
#endif
AFS_STATCNT(osi_Alloc);
@ -78,8 +78,8 @@ afs_osi_Alloc(size_t x)
void *
afs_osi_Alloc_NoSleep(size_t x)
{
register struct osimem *tm;
register int size;
struct osimem *tm;
int size;
AFS_STATCNT(osi_Alloc);
/* 0-length allocs may return NULL ptr from AFS_KALLOC, so we special-case
@ -158,7 +158,7 @@ osi_FreeSmallSpace(void *adata)
void *
osi_AllocLargeSpace(size_t size)
{
register struct osi_packet *tp;
struct osi_packet *tp;
AFS_ASSERT_GLOCK();
@ -194,7 +194,7 @@ osi_AllocLargeSpace(size_t size)
void *
osi_AllocSmallSpace(size_t size)
{
register struct osi_packet *tp;
struct osi_packet *tp;
AFS_STATCNT(osi_AllocSmallSpace);
if (size > AFS_SMALLOCSIZ)

2
src/afs/afs_osi_pag.c
View File

@ -448,7 +448,7 @@ AddPag(afs_int32 aval, afs_ucred_t **credpp)
int
afs_InitReq(register struct vrequest *av, afs_ucred_t *acred)
afs_InitReq(struct vrequest *av, afs_ucred_t *acred)
{
#if defined(AFS_LINUX26_ENV) && !defined(AFS_NONFSTRANS)
int code;

18
src/afs/afs_osi_uio.c
View File

@ -27,10 +27,10 @@
/* routine to make copy of uio structure in ainuio, using aoutvec for space */
int
afsio_copy(struct uio *ainuio, struct uio *aoutuio,
register struct iovec *aoutvec)
struct iovec *aoutvec)
{
register int i;
register struct iovec *tvec;
int i;
struct iovec *tvec;
AFS_STATCNT(afsio_copy);
if (ainuio->afsio_iovcnt > AFS_MAXIOVCNT)
@ -48,10 +48,10 @@ afsio_copy(struct uio *ainuio, struct uio *aoutuio,
/* trim the uio structure to the specified size */
int
afsio_trim(register struct uio *auio, register afs_int32 asize)
afsio_trim(struct uio *auio, afs_int32 asize)
{
register int i;
register struct iovec *tv;
int i;
struct iovec *tv;
AFS_STATCNT(afsio_trim);
auio->afsio_resid = asize;
@ -79,10 +79,10 @@ afsio_trim(register struct uio *auio, register afs_int32 asize)
/* skip asize bytes in the current uio structure */
int
afsio_skip(register struct uio *auio, register afs_int32 asize)
afsio_skip(struct uio *auio, afs_int32 asize)
{
register struct iovec *tv; /* pointer to current iovec */
register int cnt;
struct iovec *tv; /* pointer to current iovec */
int cnt;
AFS_STATCNT(afsio_skip);
#ifdef AFS_DARWIN80_ENV

4
src/afs/afs_osi_vget.c
View File

@ -28,9 +28,9 @@ afs_osi_vget(struct vcache **avcpp, struct fid *afidp, struct vrequest *areqp)
{
struct VenusFid vfid;
struct SmallFid Sfid;
register struct cell *tcell;
struct cell *tcell;
struct vrequest treq;
register afs_int32 code = 0, cellindex;
afs_int32 code = 0, cellindex;
afs_int32 ret;
memcpy((char *)&Sfid, afidp->fid_data, SIZEOF_SMALLFID);

6
src/afs/afs_osi_vm.c
View File

@ -19,7 +19,7 @@
#endif
int
osi_Active(register struct vcache *avc)
osi_Active(struct vcache *avc)
{
AFS_STATCNT(osi_Active);
#if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
@ -45,7 +45,7 @@ osi_Active(register struct vcache *avc)
us, of course).
*/
void
osi_FlushPages(register struct vcache *avc, afs_ucred_t *credp)
osi_FlushPages(struct vcache *avc, afs_ucred_t *credp)
{
#ifdef AFS_FBSD70_ENV
int vfslocked;
@ -121,7 +121,7 @@ osi_FlushPages(register struct vcache *avc, afs_ucred_t *credp)
* it is written to the file system. */
void
osi_FlushText_really(register struct vcache *vp)
osi_FlushText_really(struct vcache *vp)
{
afs_hyper_t fdv; /* version before which we'll flush */

6
src/afs/afs_pag_cred.c
View File

@ -94,8 +94,8 @@ afspag_SetPrimaryCell(char *acell)
int
afspag_PUnlog(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
{
register afs_int32 i;
register struct unixuser *tu;
afs_int32 i;
struct unixuser *tu;
afs_int32 pag, uid;
AFS_STATCNT(PUnlog);
@ -130,7 +130,7 @@ int
afspag_PSetTokens(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
{
afs_int32 i;
register struct unixuser *tu;
struct unixuser *tu;
struct afspag_cell *tcell;
struct ClearToken clear;
char *stp;

184
src/afs/afs_pioctl.c
View File

@ -311,10 +311,10 @@ static int HandleClientContext(struct afs_ioctl *ablob, int *com,
afs_ucred_t **acred,
afs_ucred_t *credp);
#endif
int HandleIoctl(register struct vcache *avc, register afs_int32 acom,
int HandleIoctl(struct vcache *avc, afs_int32 acom,
struct afs_ioctl *adata);
int afs_HandlePioctl(struct vnode *avp, afs_int32 acom,
register struct afs_ioctl *ablob, int afollow,
struct afs_ioctl *ablob, int afollow,
afs_ucred_t **acred);
static int Prefetch(uparmtype apath, struct afs_ioctl *adata, int afollow,
afs_ucred_t *acred);
@ -427,10 +427,10 @@ static pioctlFunction OpioctlSw[] = {
int afs_nobody = NFS_NOBODY;
int
HandleIoctl(register struct vcache *avc, register afs_int32 acom,
HandleIoctl(struct vcache *avc, afs_int32 acom,
struct afs_ioctl *adata)
{
register afs_int32 code;
afs_int32 code;
code = 0;
AFS_STATCNT(HandleIoctl);
@ -448,8 +448,8 @@ HandleIoctl(register struct vcache *avc, register afs_int32 acom,
case 3:{
/* return the name of the cell this file is open on */
register struct cell *tcell;
register afs_int32 i;
struct cell *tcell;
afs_int32 i;
tcell = afs_GetCell(avc->f.fid.Cell, READ_LOCK);
if (tcell) {
@ -537,8 +537,8 @@ kioctl(int fdes, int com, caddr_t arg, caddr_t ext)
# endif
} u_uap, *uap = &u_uap;
struct file *fd;
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
struct vcache *tvc;
int ioctlDone = 0, code = 0;
AFS_STATCNT(afs_xioctl);
uap->fd = fdes;
@ -557,7 +557,7 @@ kioctl(int fdes, int com, caddr_t arg, caddr_t ext)
if (tvc && IsAfsVnode(AFSTOV(tvc))) {
/* This is an AFS vnode */
if (((uap->com >> 8) & 0xff) == 'V') {
register struct afs_ioctl *datap;
struct afs_ioctl *datap;
AFS_GLOCK();
datap =
(struct afs_ioctl *)osi_AllocSmallSpace(AFS_SMALLOCSIZ);
@ -654,8 +654,8 @@ int
afs_xioctl(struct afs_ioctl_sys *uap, rval_t *rvp)
{
struct file *fd;
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
struct vcache *tvc;
int ioctlDone = 0, code = 0;
AFS_STATCNT(afs_xioctl);
# if defined(AFS_SUN57_ENV)
@ -676,7 +676,7 @@ afs_xioctl(struct afs_ioctl_sys *uap, rval_t *rvp)
if (tvc && IsAfsVnode(AFSTOV(tvc))) {
/* This is an AFS vnode */
if (((uap->com >> 8) & 0xff) == 'V') {
register struct afs_ioctl *datap;
struct afs_ioctl *datap;
AFS_GLOCK();
datap =
(struct afs_ioctl *)osi_AllocSmallSpace(AFS_SMALLOCSIZ);
@ -720,8 +720,8 @@ afs_xioctl(struct inode *ip, struct file *fp, unsigned int com,
unsigned long arg)
{
struct afs_ioctl_sys ua, *uap = &ua;
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
struct vcache *tvc;
int ioctlDone = 0, code = 0;
AFS_STATCNT(afs_xioctl);
ua.com = com;
@ -731,7 +731,7 @@ afs_xioctl(struct inode *ip, struct file *fp, unsigned int com,
if (tvc && IsAfsVnode(AFSTOV(tvc))) {
/* This is an AFS vnode */
if (((uap->com >> 8) & 0xff) == 'V') {
register struct afs_ioctl *datap;
struct afs_ioctl *datap;
AFS_GLOCK();
datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
code = copyin_afs_ioctl((char *)uap->arg, datap);
@ -758,11 +758,11 @@ struct ioctl_args {
};
int
afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
afs_xioctl(afs_proc_t *p, struct ioctl_args *uap, register_t *retval)
{
struct file *fd;
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
struct vcache *tvc;
int ioctlDone = 0, code = 0;
AFS_STATCNT(afs_xioctl);
if ((code = fdgetf(p, uap->fd, &fd)))
@ -772,7 +772,7 @@ afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
if (tvc && IsAfsVnode(AFSTOV(tvc))) {
/* This is an AFS vnode */
if (((uap->com >> 8) & 0xff) == 'V') {
register struct afs_ioctl *datap;
struct afs_ioctl *datap;
AFS_GLOCK();
datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
code = copyin_afs_ioctl((char *)uap->arg, datap);
@ -798,7 +798,7 @@ afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
# if defined(AFS_FBSD_ENV)
# define arg data
int
afs_xioctl(struct thread *td, register struct ioctl_args *uap,
afs_xioctl(struct thread *td, struct ioctl_args *uap,
register_t *retval)
{
afs_proc_t *p = td->td_proc;
@ -810,12 +810,12 @@ struct ioctl_args {
};
int
afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
afs_xioctl(afs_proc_t *p, struct ioctl_args *uap, register_t *retval)
{
# endif
register struct filedesc *fdp;
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
struct filedesc *fdp;
struct vcache *tvc;
int ioctlDone = 0, code = 0;
struct file *fd;
AFS_STATCNT(afs_xioctl);
@ -842,7 +842,7 @@ afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
if (tvc && IsAfsVnode(AFSTOV(tvc))) {
/* This is an AFS vnode */
if (((uap->com >> 8) & 0xff) == 'V') {
register struct afs_ioctl *datap;
struct afs_ioctl *datap;
AFS_GLOCK();
datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
code = copyin_afs_ioctl((char *)uap->arg, datap);
@ -876,14 +876,14 @@ afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
int
afs_xioctl(void)
{
register struct a {
struct a {
int fd;
int com;
caddr_t arg;
} *uap = (struct a *)get_user_struct()->u_ap;
register struct file *fd;
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
struct file *fd;
struct vcache *tvc;
int ioctlDone = 0, code = 0;
AFS_STATCNT(afs_xioctl);
@ -897,7 +897,7 @@ afs_xioctl(void)
if (tvc && IsAfsVnode(AFSTOV(tvc))) {
/* This is an AFS vnode */
if (((uap->com >> 8) & 0xff) == 'V') {
register struct afs_ioctl *datap;
struct afs_ioctl *datap;
AFS_GLOCK();
datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
code=copyin_afs_ioctl((char *)uap->arg, datap);
@ -1023,7 +1023,7 @@ afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow)
#if defined(AFS_NEED_CLIENTCONTEXT) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_LINUX22_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
afs_ucred_t *foreigncreds = NULL;
#endif
register afs_int32 code = 0;
afs_int32 code = 0;
struct vnode *vp = NULL;
#ifdef AFS_AIX41_ENV
struct ucred *credp = crref(); /* don't free until done! */
@ -1260,13 +1260,13 @@ afs_syscall_pioctl(char * path, unsigned int com, caddr_t cmarg,
int
afs_HandlePioctl(struct vnode *avp, afs_int32 acom,
register struct afs_ioctl *ablob, int afollow,
struct afs_ioctl *ablob, int afollow,
afs_ucred_t **acred)
{
struct vcache *avc;
struct vrequest treq;
register afs_int32 code;
register afs_int32 function, device;
afs_int32 code;
afs_int32 function, device;
struct afs_pdata input, output;
struct afs_pdata copyInput, copyOutput;
size_t outSize;
@ -1409,7 +1409,7 @@ dummy_PSetAcl(char *ain, char *aout)
DECL_PIOCTL(PSetAcl)
{
register afs_int32 code;
afs_int32 code;
struct afs_conn *tconn;
struct AFSOpaque acl;
struct AFSVolSync tsync;
@ -1671,7 +1671,7 @@ DECL_PIOCTL(PBogus)
*/
DECL_PIOCTL(PGetFileCell)
{
register struct cell *tcell;
struct cell *tcell;
AFS_STATCNT(PGetFileCell);
if (!avc)
@ -1735,9 +1735,9 @@ DECL_PIOCTL(PGetWSCell)
*/
DECL_PIOCTL(PGetUserCell)
{
register afs_int32 i;
register struct unixuser *tu;
register struct cell *tcell;
afs_int32 i;
struct unixuser *tu;
struct cell *tcell;
AFS_STATCNT(PGetUserCell);
if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
@ -1792,9 +1792,9 @@ DECL_PIOCTL(PGetUserCell)
DECL_PIOCTL(PSetTokens)
{
afs_int32 i;
register struct unixuser *tu;
struct unixuser *tu;
struct ClearToken clear;
register struct cell *tcell;
struct cell *tcell;
char *stp;
char *cellName;
int stLen;
@ -1928,8 +1928,8 @@ DECL_PIOCTL(PGetVolumeStatus)
char volName[32];
char *offLineMsg = afs_osi_Alloc(256);
char *motd = afs_osi_Alloc(256);
register struct afs_conn *tc;
register afs_int32 code = 0;
struct afs_conn *tc;
afs_int32 code = 0;
struct AFSFetchVolumeStatus volstat;
char *Name;
XSTATS_DECLS;
@ -2002,11 +2002,11 @@ DECL_PIOCTL(PSetVolumeStatus)
char *volName;
char *offLineMsg;
char *motd;
register struct afs_conn *tc;
register afs_int32 code = 0;
struct afs_conn *tc;
afs_int32 code = 0;
struct AFSFetchVolumeStatus volstat;
struct AFSStoreVolumeStatus storeStat;
register struct volume *tvp;
struct volume *tvp;
XSTATS_DECLS;
AFS_STATCNT(PSetVolumeStatus);
@ -2135,9 +2135,9 @@ DECL_PIOCTL(PFlush)
*/
DECL_PIOCTL(PNewStatMount)
{
register afs_int32 code;
register struct vcache *tvc;
register struct dcache *tdc;
afs_int32 code;
struct vcache *tvc;
struct dcache *tdc;
struct VenusFid tfid;
char *bufp;
char *name;
@ -2235,9 +2235,9 @@ DECL_PIOCTL(PNewStatMount)
DECL_PIOCTL(PGetTokens)
{
register struct cell *tcell;
register afs_int32 i;
register struct unixuser *tu;
struct cell *tcell;
afs_int32 i;
struct unixuser *tu;
afs_int32 iterator = 0;
int newStyle;
int code = E2BIG;
@ -2349,8 +2349,8 @@ out:
*/
DECL_PIOCTL(PUnlog)
{
register afs_int32 i;
register struct unixuser *tu;
afs_int32 i;
struct unixuser *tu;
AFS_STATCNT(PUnlog);
if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
@ -2453,8 +2453,8 @@ DECL_PIOCTL(PMariner)
*/
DECL_PIOCTL(PCheckServers)
{
register int i;
register struct server *ts;
int i;
struct server *ts;
afs_int32 temp;
char *cellName = NULL;
struct cell *cellp;
@ -2627,8 +2627,8 @@ static int
Prefetch(uparmtype apath, struct afs_ioctl *adata, int afollow,
afs_ucred_t *acred)
{
register char *tp;
register afs_int32 code;
char *tp;
afs_int32 code;
#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
size_t bufferSize;
#else
@ -2670,9 +2670,9 @@ Prefetch(uparmtype apath, struct afs_ioctl *adata, int afollow,
*/
DECL_PIOCTL(PFindVolume)
{
register struct volume *tvp;
register struct server *ts;
register afs_int32 i;
struct volume *tvp;
struct server *ts;
afs_int32 i;
int code = 0;
AFS_STATCNT(PFindVolume);
@ -2718,7 +2718,7 @@ out:
*/
DECL_PIOCTL(PViceAccess)
{
register afs_int32 code;
afs_int32 code;
afs_int32 temp;
AFS_STATCNT(PViceAccess);
@ -2838,7 +2838,7 @@ DECL_PIOCTL(PGetCacheSize)
{
afs_int32 results[MAXGCSTATS];
afs_int32 flags;
register struct dcache * tdc;
struct dcache * tdc;
int i, size;
AFS_STATCNT(PGetCacheSize);
@ -2903,8 +2903,8 @@ DECL_PIOCTL(PGetCacheSize)
*/
DECL_PIOCTL(PRemoveCallBack)
{
register struct afs_conn *tc;
register afs_int32 code = 0;
struct afs_conn *tc;
afs_int32 code = 0;
struct AFSCallBack CallBacks_Array[1];
struct AFSCBFids theFids;
struct AFSCBs theCBs;
@ -3077,8 +3077,8 @@ DECL_PIOCTL(PNewAlias)
DECL_PIOCTL(PListCells)
{
afs_int32 whichCell;
register struct cell *tcell = 0;
register afs_int32 i;
struct cell *tcell = 0;
afs_int32 i;
int code;
AFS_STATCNT(PListCells);
@ -3116,7 +3116,7 @@ out:
DECL_PIOCTL(PListAliases)
{
afs_int32 whichAlias;
register struct cell_alias *tcalias = 0;
struct cell_alias *tcalias = 0;
int code;
if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
@ -3163,14 +3163,14 @@ out:
*/
DECL_PIOCTL(PRemoveMount)
{
register afs_int32 code;
afs_int32 code;
char *bufp;
char *name;
struct sysname_info sysState;
afs_size_t offset, len;
register struct afs_conn *tc;
register struct dcache *tdc;
register struct vcache *tvc;
struct afs_conn *tc;
struct dcache *tdc;
struct vcache *tvc;
struct AFSFetchStatus OutDirStatus;
struct VenusFid tfid;
struct AFSVolSync tsync;
@ -3300,7 +3300,7 @@ DECL_PIOCTL(PRemoveMount)
*/
DECL_PIOCTL(PGetCellStatus)
{
register struct cell *tcell;
struct cell *tcell;
char *cellName;
afs_int32 temp;
@ -3340,7 +3340,7 @@ DECL_PIOCTL(PGetCellStatus)
*/
DECL_PIOCTL(PSetCellStatus)
{
register struct cell *tcell;
struct cell *tcell;
char *cellName;
afs_int32 flags0, flags1;
@ -3389,10 +3389,10 @@ DECL_PIOCTL(PSetCellStatus)
*/
DECL_PIOCTL(PFlushVolumeData)
{
register afs_int32 i;
register struct dcache *tdc;
register struct vcache *tvc;
register struct volume *tv;
afs_int32 i;
struct dcache *tdc;
struct vcache *tvc;
struct volume *tv;
afs_int32 cell, volume;
struct afs_q *tq, *uq;
#ifdef AFS_DARWIN80_ENV
@ -3546,7 +3546,7 @@ DECL_PIOCTL(PFlushVolumeData)
*/
DECL_PIOCTL(PGetVnodeXStatus)
{
register afs_int32 code;
afs_int32 code;
struct vcxstat stat;
afs_int32 mode, i;
@ -3594,7 +3594,7 @@ DECL_PIOCTL(PGetVnodeXStatus)
DECL_PIOCTL(PGetVnodeXStatus2)
{
register afs_int32 code;
afs_int32 code;
struct vcxstat2 stat;
afs_int32 mode;
@ -3653,9 +3653,9 @@ DECL_PIOCTL(PSetSysName)
char outname[MAXSYSNAME];
afs_int32 setsysname;
int foundname = 0;
register struct afs_exporter *exporter;
register struct unixuser *au;
register afs_int32 pag, error;
struct afs_exporter *exporter;
struct unixuser *au;
afs_int32 pag, error;
int t, count, num = 0, allpags = 0;
char **sysnamelist;
struct afs_pdata validate;
@ -3821,7 +3821,7 @@ ReSortCells(int s, afs_int32 * l, int vlonly)
{
int i;
struct volume *j;
register int k;
int k;
if (vlonly) {
afs_int32 *p;
@ -4120,7 +4120,7 @@ DECL_PIOCTL(PExportAfs)
afs_int32 export, newint = 0;
afs_int32 type, changestate, handleValue, convmode, pwsync, smounts;
afs_int32 rempags = 0, pagcb = 0;
register struct afs_exporter *exporter;
struct afs_exporter *exporter;
AFS_STATCNT(PExportAfs);
if (afs_pd_getInt(ain, &handleValue) != 0)
@ -4689,9 +4689,9 @@ DECL_PIOCTL(PSetCPrefs)
*/
DECL_PIOCTL(PFlushMount)
{
register afs_int32 code;
register struct vcache *tvc;
register struct dcache *tdc;
afs_int32 code;
struct vcache *tvc;
struct dcache *tdc;
struct VenusFid tfid;
char *bufp;
char *mount;
@ -4850,7 +4850,7 @@ DECL_PIOCTL(PRxStatPeer)
DECL_PIOCTL(PPrefetchFromTape)
{
register afs_int32 code, code1;
afs_int32 code, code1;
afs_int32 bytes, outval;
struct afs_conn *tc;
struct rx_call *tcall;
@ -4916,7 +4916,7 @@ DECL_PIOCTL(PPrefetchFromTape)
DECL_PIOCTL(PFsCmd)
{
register afs_int32 code;
afs_int32 code;
struct afs_conn *tc;
struct vcache *tvc;
struct FsCmdInputs *Inputs;
@ -5213,8 +5213,8 @@ DECL_PIOCTL(PDiscon)
DECL_PIOCTL(PNFSNukeCreds)
{
afs_uint32 addr;
register afs_int32 i;
register struct unixuser *tu;
afs_int32 i;
struct unixuser *tu;
AFS_STATCNT(PUnlog);
if (!afs_resourceinit_flag) /* afs daemons haven't started yet */

294
src/afs/afs_prototypes.h
View File

@ -11,8 +11,8 @@
#define _AFS_PROTOTYPES_H_
/* afs_analyze.c */
extern int afs_Analyze(register struct afs_conn *aconn, afs_int32 acode,
struct VenusFid *afid, register struct vrequest *areq,
extern int afs_Analyze(struct afs_conn *aconn, afs_int32 acode,
struct VenusFid *afid, struct vrequest *areq,
int op, afs_int32 locktype, struct cell *cellp);
/* afs_axscache.c */
@ -26,12 +26,12 @@ extern void shutdown_xscache(void);
/* afs_buffer.c */
extern void DInit(int abuffers);
extern void *DRead(register struct dcache * fid, register int page);
extern int DVOffset(register void *ap);
extern void *DRead(struct dcache * fid, int page);
extern int DVOffset(void *ap);
extern void DZap(struct dcache * fid);
extern void DFlush(void);
extern void DFlushDCache(struct dcache *);
extern void *DNew(register struct dcache * fid, register int page);
extern void *DNew(struct dcache * fid, int page);
extern void shutdown_bufferpackage(void);
/* afs_call.c */
@ -73,7 +73,7 @@ extern int SRXAFSCB_GetCE64(struct rx_call *a_call, afs_int32 a_index,
extern int SRXAFSCB_GetLock(struct rx_call *a_call, afs_int32 a_index,
struct AFSDBLock *a_result);
extern int SRXAFSCB_CallBack(struct rx_call *a_call,
register struct AFSCBFids *a_fids,
struct AFSCBFids *a_fids,
struct AFSCBs *a_callbacks);
extern int SRXAFSCB_Probe(struct rx_call *a_call);
extern int SRXAFSCB_InitCallBackState(struct rx_call *a_call);
@ -165,7 +165,7 @@ extern afs_int32 afs_OtherCSize;
extern afs_int32 afs_LogChunk;
/* afs_cell.c */
extern struct cell *afs_GetRealCellByIndex(register afs_int32 cellindex,
extern struct cell *afs_GetRealCellByIndex(afs_int32 cellindex,
afs_int32 locktype,
afs_int32 refresh);
@ -173,8 +173,8 @@ extern struct cell *afs_GetRealCellByIndex(register afs_int32 cellindex,
extern afs_int32 cryptall;
extern afs_rwlock_t afs_xinterface;
extern afs_rwlock_t afs_xconn;
extern struct afs_conn *afs_Conn(register struct VenusFid *afid,
register struct vrequest *areq,
extern struct afs_conn *afs_Conn(struct VenusFid *afid,
struct vrequest *areq,
afs_int32 locktype);
extern struct afs_conn *afs_ConnBySA(struct srvAddr *sap, unsigned short aport,
afs_int32 acell, struct unixuser *tu,
@ -182,13 +182,13 @@ extern struct afs_conn *afs_ConnBySA(struct srvAddr *sap, unsigned short aport,
afs_int32 locktype);
extern struct afs_conn *afs_ConnByMHosts(struct server *ahosts[],
unsigned short aport, afs_int32 acell,
register struct vrequest *areq,
struct vrequest *areq,
afs_int32 locktype);
extern struct afs_conn *afs_ConnByHost(struct server *aserver,
unsigned short aport, afs_int32 acell,
struct vrequest *areq, int aforce,
afs_int32 locktype);
extern void afs_PutConn(register struct afs_conn *ac, afs_int32 locktype);
extern void afs_PutConn(struct afs_conn *ac, afs_int32 locktype);
extern void ForceNewConnections(struct srvAddr *sap);
@ -205,8 +205,8 @@ extern afs_int32 afs_probe_interval;
extern afs_int32 afs_preCache;
extern void afs_Daemon(void);
extern struct brequest *afs_BQueue(register short aopcode,
register struct vcache *avc,
extern struct brequest *afs_BQueue(short aopcode,
struct vcache *avc,
afs_int32 dontwait, afs_int32 ause,
afs_ucred_t *acred,
afs_size_t asparm0, afs_size_t asparm1,
@ -215,7 +215,7 @@ extern struct brequest *afs_BQueue(register short aopcode,
extern void afs_SetCheckServerNATmode(int isnat);
extern void afs_CheckServerDaemon(void);
extern int afs_CheckRootVolume(void);
extern void afs_BRelease(register struct brequest *ab);
extern void afs_BRelease(struct brequest *ab);
extern int afs_BBusy(void);
extern int afs_BioDaemon(afs_int32 nbiods);
#ifdef AFS_DARWIN80_ENV
@ -244,38 +244,38 @@ extern afs_dcache_id_t cacheInode;
extern struct osi_file *afs_cacheInodep;
extern void afs_dcacheInit(int afiles, int ablocks, int aDentries, int achunk,
int aflags);
extern int afs_PutDCache(register struct dcache *adc);
extern void afs_FlushDCache(register struct dcache *adc);
extern int afs_PutDCache(struct dcache *adc);
extern void afs_FlushDCache(struct dcache *adc);
extern void shutdown_dcache(void);
extern void afs_CacheTruncateDaemon(void);
extern afs_int32 afs_fsfragsize;
extern struct dcache *afs_MemGetDSlot(register afs_int32 aslot,
register struct dcache *tmpdc);
extern struct dcache *afs_GetDCache(register struct vcache *avc,
extern struct dcache *afs_MemGetDSlot(afs_int32 aslot,
struct dcache *tmpdc);
extern struct dcache *afs_GetDCache(struct vcache *avc,
afs_size_t abyte,
register struct vrequest *areq,
struct vrequest *areq,
afs_size_t * aoffset, afs_size_t * alen,
int aflags);
extern struct dcache *afs_FindDCache(register struct vcache *avc,
extern struct dcache *afs_FindDCache(struct vcache *avc,
afs_size_t abyte);
extern void afs_StoreWarn(register afs_int32 acode, afs_int32 avolume,
register afs_int32 aflags);
extern void afs_StoreWarn(afs_int32 acode, afs_int32 avolume,
afs_int32 aflags);
extern void afs_MaybeWakeupTruncateDaemon(void);
extern void afs_CacheTruncateDaemon(void);
extern void afs_AdjustSize(register struct dcache *adc,
register afs_int32 newSize);
extern void afs_AdjustSize(struct dcache *adc,
afs_int32 newSize);
extern int afs_HashOutDCache(struct dcache *adc, int zap);
extern int afs_MaybeFreeDiscardedDCache(void);
extern int afs_RefDCache(struct dcache *adc);
extern void afs_TryToSmush(register struct vcache *avc,
extern void afs_TryToSmush(struct vcache *avc,
afs_ucred_t *acred, int sync);
extern void updateV2DC(int lockVc, struct vcache *v, struct dcache *d,
int src);
extern void afs_WriteThroughDSlots(void);
extern struct dcache *afs_UFSGetDSlot(register afs_int32 aslot,
register struct dcache *tmpdc);
extern int afs_WriteDCache(register struct dcache *adc, int atime);
extern int afs_wakeup(register struct vcache *avc);
extern struct dcache *afs_UFSGetDSlot(afs_int32 aslot,
struct dcache *tmpdc);
extern int afs_WriteDCache(struct dcache *adc, int atime);
extern int afs_wakeup(struct vcache *avc);
extern int afs_InitCacheFile(char *afile, ino_t ainode);
extern int afs_DCacheMissingChunks(struct vcache *avc);
extern struct dcache *afs_ObtainDCacheForWriting(struct vcache *avc,
@ -318,8 +318,8 @@ extern void init_et_to_sys_error(void);
extern afs_int32 et_to_sys_error(afs_int32 in);
extern void afs_FinalizeReq(struct vrequest *areq);
extern int afs_CheckCode(afs_int32 acode, struct vrequest *areq, int where);
extern void afs_CopyError(register struct vrequest *afrom,
register struct vrequest *ato);
extern void afs_CopyError(struct vrequest *afrom,
struct vrequest *ato);
extern void init_sys_error_to_et(void);
/* afs_exporter.c */
@ -347,22 +347,22 @@ extern int afs_icl_CreateLog(char *name, afs_int32 logSize,
extern int afs_icl_CreateLogWithFlags(char *name, afs_int32 logSize,
afs_uint32 flags,
struct afs_icl_log **outLogpp);
extern int afs_icl_CopyOut(register struct afs_icl_log *logp,
extern int afs_icl_CopyOut(struct afs_icl_log *logp,
afs_int32 * bufferp, afs_int32 * bufSizep,
afs_uint32 * cookiep, afs_int32 * flagsp);
extern int afs_icl_GetLogParms(struct afs_icl_log *logp, afs_int32 * maxSizep,
afs_int32 * curSizep);
extern int afs_icl_LogHold(register struct afs_icl_log *logp);
extern int afs_icl_LogHoldNL(register struct afs_icl_log *logp);
extern int afs_icl_LogUse(register struct afs_icl_log *logp);
extern int afs_icl_LogFreeUse(register struct afs_icl_log *logp);
extern int afs_icl_LogSetSize(register struct afs_icl_log *logp,
extern int afs_icl_LogHold(struct afs_icl_log *logp);
extern int afs_icl_LogHoldNL(struct afs_icl_log *logp);
extern int afs_icl_LogUse(struct afs_icl_log *logp);
extern int afs_icl_LogFreeUse(struct afs_icl_log *logp);
extern int afs_icl_LogSetSize(struct afs_icl_log *logp,
afs_int32 logSize);
extern int afs_icl_ZapLog(register struct afs_icl_log *logp);
extern int afs_icl_LogRele(register struct afs_icl_log *logp);
extern int afs_icl_LogReleNL(register struct afs_icl_log *logp);
extern int afs_icl_ZeroLog(register struct afs_icl_log *logp);
extern int afs_icl_LogFree(register struct afs_icl_log *logp);
extern int afs_icl_ZapLog(struct afs_icl_log *logp);
extern int afs_icl_LogRele(struct afs_icl_log *logp);
extern int afs_icl_LogReleNL(struct afs_icl_log *logp);
extern int afs_icl_ZeroLog(struct afs_icl_log *logp);
extern int afs_icl_LogFree(struct afs_icl_log *logp);
extern struct afs_icl_log *afs_icl_FindLog(char *name);
extern int
afs_icl_EnumerateLogs(int (*aproc)
@ -390,26 +390,26 @@ extern int
extern int afs_icl_AddLogToSet(struct afs_icl_set *setp,
struct afs_icl_log *newlogp);
extern int afs_icl_SetSetStat(struct afs_icl_set *setp, int op);
extern int afs_icl_SetHold(register struct afs_icl_set *setp);
extern int afs_icl_ZapSet(register struct afs_icl_set *setp);
extern int afs_icl_SetRele(register struct afs_icl_set *setp);
extern int afs_icl_SetFree(register struct afs_icl_set *setp);
extern int afs_icl_SetHold(struct afs_icl_set *setp);
extern int afs_icl_ZapSet(struct afs_icl_set *setp);
extern int afs_icl_SetRele(struct afs_icl_set *setp);
extern int afs_icl_SetFree(struct afs_icl_set *setp);
extern struct afs_icl_set *afs_icl_FindSet(char *name);
extern int afs_icl_Event4(register struct afs_icl_set *setp,
extern int afs_icl_Event4(struct afs_icl_set *setp,
afs_int32 eventID, afs_int32 lAndT, long p1,
long p2, long p3, long p4);
extern int afs_icl_Event3(register struct afs_icl_set *setp,
extern int afs_icl_Event3(struct afs_icl_set *setp,
afs_int32 eventID, afs_int32 lAndT, long p1,
long p2, long p3);
extern int afs_icl_Event2(register struct afs_icl_set *setp,
extern int afs_icl_Event2(struct afs_icl_set *setp,
afs_int32 eventID, afs_int32 lAndT, long p1,
long p2);
extern int afs_icl_Event1(register struct afs_icl_set *setp,
extern int afs_icl_Event1(struct afs_icl_set *setp,
afs_int32 eventID, afs_int32 lAndT, long p1);
extern int afs_icl_Event0(register struct afs_icl_set *setp,
extern int afs_icl_Event0(struct afs_icl_set *setp,
afs_int32 eventID, afs_int32 lAndT);
extern void afs_icl_AppendRecord(register struct afs_icl_log *logp,
extern void afs_icl_AppendRecord(struct afs_icl_log *logp,
afs_int32 op, afs_int32 types, long p1,
long p2, long p3, long p4);
extern int Afscall_icl(long opcode, long p1, long p2, long p3, long p4,
@ -434,7 +434,7 @@ extern int afs_CacheInit(afs_int32 astatSize, afs_int32 afiles,
afs_int32 aflags, afs_int32 ninodes,
afs_int32 nusers, afs_int32 dynamic_vcaches);
extern void afs_ComputeCacheParms(void);
extern int afs_InitCacheInfo(register char *afile);
extern int afs_InitCacheInfo(char *afile);
extern int afs_InitVolumeInfo(char *afile);
extern int afs_InitCellInfo(char *afile);
extern int afs_ResourceInit(int preallocs);
@ -445,21 +445,21 @@ extern int afs_LookupInodeByPath(char *filename, afs_ufs_dcache_id_t *inode,
struct vnode **fvpp);
/* afs_lock.c */
extern void Lock_Init(register struct afs_lock *lock);
extern void ObtainLock(register struct afs_lock *lock, int how,
extern void Lock_Init(struct afs_lock *lock);
extern void ObtainLock(struct afs_lock *lock, int how,
unsigned int src_indicator);
extern void ReleaseLock(register struct afs_lock *lock, int how);
extern void ReleaseLock(struct afs_lock *lock, int how);
extern int Afs_Lock_Trace(int op, struct afs_lock *alock, int type,
char *file, int line);
extern void Afs_Lock_Obtain(register struct afs_lock *lock, int how);
extern void Afs_Lock_ReleaseR(register struct afs_lock *lock);
extern void Afs_Lock_ReleaseW(register struct afs_lock *lock);
extern void afs_osi_SleepR(register char *addr,
register struct afs_lock *alock);
extern void afs_osi_SleepW(register char *addr,
register struct afs_lock *alock);
extern void afs_osi_SleepS(register char *addr,
register struct afs_lock *alock);
extern void Afs_Lock_Obtain(struct afs_lock *lock, int how);
extern void Afs_Lock_ReleaseR(struct afs_lock *lock);
extern void Afs_Lock_ReleaseW(struct afs_lock *lock);
extern void afs_osi_SleepR(char *addr,
struct afs_lock *alock);
extern void afs_osi_SleepW(char *addr,
struct afs_lock *alock);
extern void afs_osi_SleepS(char *addr,
struct afs_lock *alock);
#ifndef AFS_NOBOZO_LOCK
extern void afs_BozonLock(struct afs_bozoLock *alock, struct vcache *avc);
extern void afs_BozonUnlock(struct afs_bozoLock *alock, struct vcache *avc);
@ -475,15 +475,15 @@ extern int afs_CheckBozonLockBlocking(struct afs_bozoLock *alock);
extern afs_int32 afs_mariner;
extern afs_int32 afs_marinerHost;
extern struct rx_service *afs_server;
extern int afs_AddMarinerName(register char *aname,
register struct vcache *avc);
extern char *afs_GetMariner(register struct vcache *avc);
extern void afs_MarinerLogFetch(register struct vcache *avc,
register afs_int32 off,
register afs_int32 bytes,
register afs_int32 idx);
extern void afs_MarinerLog(register char *astring,
register struct vcache *avc);
extern int afs_AddMarinerName(char *aname,
struct vcache *avc);
extern char *afs_GetMariner(struct vcache *avc);
extern void afs_MarinerLogFetch(struct vcache *avc,
afs_int32 off,
afs_int32 bytes,
afs_int32 idx);
extern void afs_MarinerLog(char *astring,
struct vcache *avc);
extern void shutdown_mariner(void);
/* afs_fetchstore.c */
@ -502,17 +502,17 @@ extern int afs_CacheFetchProc(struct afs_conn *tc, struct osi_file *fP,
extern int afs_InitMemCache(int blkCount, int blkSize, int flags);
extern int afs_MemCacheClose(struct osi_file *file);
extern void *afs_MemCacheOpen(afs_dcache_id_t *ainode);
extern int afs_MemReadBlk(register struct osi_file *fP, int offset,
extern int afs_MemReadBlk(struct osi_file *fP, int offset,
void *dest, int size);
extern int afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset,
extern int afs_MemReadvBlk(struct memCacheEntry *mceP, int offset,
struct iovec *iov, int nio, int size);
extern int afs_MemReadUIO(afs_dcache_id_t *ainode, struct uio *uioP);
extern int afs_MemWriteBlk(register struct osi_file *fP, int offset,
extern int afs_MemWriteBlk(struct osi_file *fP, int offset,
void *src, int size);
extern int afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset,
extern int afs_MemWritevBlk(struct memCacheEntry *mceP, int offset,
struct iovec *iov, int nio, int size);
extern int afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP);
extern int afs_MemCacheTruncate(register struct osi_file *fP,
extern int afs_MemCacheTruncate(struct osi_file *fP,
int size);
extern void shutdown_memcache(void);
@ -590,7 +590,7 @@ extern int AddPag(afs_proc_t *p, afs_int32 aval, afs_ucred_t **credpp);
#else
extern int AddPag(afs_int32 aval, afs_ucred_t **credpp);
#endif
extern int afs_InitReq(register struct vrequest *av, afs_ucred_t *acred);
extern int afs_InitReq(struct vrequest *av, afs_ucred_t *acred);
extern afs_uint32 afs_get_pag_from_groups(gid_t g0a, gid_t g1a);
extern void afs_get_groups_from_pag(afs_uint32 pag, gid_t * g0p, gid_t * g1p);
extern afs_int32 PagInCred(afs_ucred_t *cred);
@ -602,10 +602,10 @@ extern int afsio_trim(struct uio *auio, afs_int32 asize);
extern int afsio_skip(struct uio *auio, afs_int32 asize);
/* afs_osi_vm.c */
extern int osi_Active(register struct vcache *avc);
extern void osi_FlushPages(register struct vcache *avc,
extern int osi_Active(struct vcache *avc);
extern void osi_FlushPages(struct vcache *avc,
afs_ucred_t *credp);
extern void osi_FlushText_really(register struct vcache *vp);
extern void osi_FlushText_really(struct vcache *vp);
extern int osi_VMDirty_p(struct vcache *avc);
#ifndef UKERNEL
extern void osi_ReleaseVM(struct vcache *avc, afs_ucred_t *acred);
@ -685,17 +685,17 @@ extern void *osi_UFSOpen(afs_dcache_id_t *ainode);
#if defined(AFS_LINUX22_ENV)
extern void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode);
#endif
extern int afs_osi_Stat(register struct osi_file *afile,
register struct osi_stat *astat);
extern int osi_UFSClose(register struct osi_file *afile);
extern int osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize);
extern int afs_osi_Stat(struct osi_file *afile,
struct osi_stat *astat);
extern int osi_UFSClose(struct osi_file *afile);
extern int osi_UFSTruncate(struct osi_file *afile, afs_int32 asize);
extern void osi_DisableAtimes(struct vnode *avp);
extern int afs_osi_Read(register struct osi_file *afile, int offset,
extern int afs_osi_Read(struct osi_file *afile, int offset,
void *aptr, afs_int32 asize);
extern int afs_osi_Write(register struct osi_file *afile, afs_int32 offset,
extern int afs_osi_Write(struct osi_file *afile, afs_int32 offset,
void *aptr, afs_int32 asize);
extern int afs_osi_MapStrategy(int (*aproc) (struct buf * bp),
register struct buf *bp);
struct buf *bp);
extern void shutdown_osifile(void);
@ -810,17 +810,17 @@ extern int afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg,
extern int afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg,
int follow);
#endif
extern int HandleIoctl(register struct vcache *avc, register afs_int32 acom,
extern int HandleIoctl(struct vcache *avc, afs_int32 acom,
struct afs_ioctl *adata);
/* afs_segments.c */
extern int afs_StoreAllSegments(register struct vcache *avc,
extern int afs_StoreAllSegments(struct vcache *avc,
struct vrequest *areq, int sync);
extern int afs_InvalidateAllSegments(struct vcache *avc);
extern int afs_ExtendSegments(struct vcache *avc,
afs_size_t alen, struct vrequest *areq);
extern int afs_TruncateAllSegments(register struct vcache *avc,
extern int afs_TruncateAllSegments(struct vcache *avc,
afs_size_t alen, struct vrequest *areq,
afs_ucred_t *acred);
@ -936,7 +936,7 @@ extern afs_rwlock_t afs_xuser;
extern struct unixuser *afs_users[NUSERS];
extern struct unixuser *afs_FindUser(afs_int32 auid, afs_int32 acell,
afs_int32 locktype);
extern struct unixuser *afs_GetUser(register afs_int32 auid, afs_int32 acell,
extern struct unixuser *afs_GetUser(afs_int32 auid, afs_int32 acell,
afs_int32 locktype);
extern void afs_NotifyUser(struct unixuser *auser, int event);
@ -945,12 +945,12 @@ extern afs_int32 afs_GCPAGs(afs_int32 * ReleasedCount);
extern void afs_GCPAGs_perproc_func(afs_proc_t * pproc);
#endif /* AFS_GCPAGS */
extern void afs_ComputePAGStats(void);
extern void afs_PutUser(register struct unixuser *au, afs_int32 locktype);
extern void afs_PutUser(struct unixuser *au, afs_int32 locktype);
extern void afs_GCUserData(int aforce);
extern void afs_CheckTokenCache(void);
extern void afs_ResetAccessCache(afs_int32 uid, int alock);
extern void afs_ResetUserConns(register struct unixuser *auser);
extern void afs_SetPrimary(register struct unixuser *au, register int aflag);
extern void afs_ResetUserConns(struct unixuser *auser);
extern void afs_SetPrimary(struct unixuser *au, int aflag);
extern void afs_MarkUserExpired(afs_int32 pag);
/* afs_util.c */
@ -1040,22 +1040,22 @@ extern struct vcache *afs_NewVCache(struct VenusFid *afid,
extern struct vcache *afs_NewBulkVCache(struct VenusFid *afid,
struct server *serverp, int seq);
extern int afs_VerifyVCache2(struct vcache *avc, struct vrequest *areq);
extern struct vcache *afs_GetVCache(register struct VenusFid *afid,
extern struct vcache *afs_GetVCache(struct VenusFid *afid,
struct vrequest *areq, afs_int32 * cached,
struct vcache *avc);
extern void afs_PutVCache(register struct vcache *avc);
extern void afs_PutVCache(struct vcache *avc);
extern int afs_RefVCache(struct vcache *avc);
extern void afs_ProcessFS(register struct vcache *avc,
register struct AFSFetchStatus *astat,
extern void afs_ProcessFS(struct vcache *avc,
struct AFSFetchStatus *astat,
struct vrequest *areq);
extern struct afs_cbr *afs_AllocCBR(void);
extern int afs_FreeCBR(register struct afs_cbr *asp);
extern void afs_RemoveVCB(register struct VenusFid *afid);
extern void afs_FlushActiveVcaches(register afs_int32 doflocks);
extern int afs_WriteVCache(register struct vcache *avc,
register struct AFSStoreStatus *astatus,
extern int afs_FreeCBR(struct afs_cbr *asp);
extern void afs_RemoveVCB(struct VenusFid *afid);
extern void afs_FlushActiveVcaches(afs_int32 doflocks);
extern int afs_WriteVCache(struct vcache *avc,
struct AFSStoreStatus *astatus,
struct vrequest *areq);
extern int afs_RemoteLookup(register struct VenusFid *afid,
extern int afs_RemoteLookup(struct VenusFid *afid,
struct vrequest *areq, char *name,
struct VenusFid *nfid,
struct AFSFetchStatus *OutStatusp,
@ -1071,24 +1071,24 @@ extern void afs_DisconGiveUpCallbacks(void);
extern void afs_ClearAllStatdFlag(void);
/* VNOPS/afs_vnop_access.c */
extern afs_int32 afs_GetAccessBits(register struct vcache *avc,
register afs_int32 arights,
register struct vrequest *areq);
extern afs_int32 afs_GetAccessBits(struct vcache *avc,
afs_int32 arights,
struct vrequest *areq);
extern int afs_AccessOK(struct vcache *avc, afs_int32 arights,
struct vrequest *areq, afs_int32 check_mode_bits);
#if defined(AFS_SUN5_ENV) || (defined(AFS_SGI_ENV) && !defined(AFS_SGI65_ENV))
extern int afs_access(OSI_VC_DECL(avc), register afs_int32 amode, int flags,
extern int afs_access(OSI_VC_DECL(avc), afs_int32 amode, int flags,
afs_ucred_t *acred);
#else
extern int afs_access(OSI_VC_DECL(avc), register afs_int32 amode,
extern int afs_access(OSI_VC_DECL(avc), afs_int32 amode,
afs_ucred_t *acred);
#endif
extern int afs_getRights(OSI_VC_DECL(avc), register afs_int32 arights,
extern int afs_getRights(OSI_VC_DECL(avc), afs_int32 arights,
afs_ucred_t *acred);
/* VNOPS/afs_vnop_attrs.c */
extern int afs_CopyOutAttrs(register struct vcache *avc,
register struct vattr *attrs);
extern int afs_CopyOutAttrs(struct vcache *avc,
struct vattr *attrs);
#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
extern int afs_getattr(OSI_VC_DECL(avc), struct vattr *attrs, int flags,
afs_ucred_t *acred);
@ -1096,14 +1096,14 @@ extern int afs_getattr(OSI_VC_DECL(avc), struct vattr *attrs, int flags,
extern int afs_getattr(OSI_VC_DECL(avc), struct vattr *attrs,
afs_ucred_t *acred);
#endif
extern int afs_VAttrToAS(register struct vcache *avc,
register struct vattr *av,
register struct AFSStoreStatus *as);
extern int afs_VAttrToAS(struct vcache *avc,
struct vattr *av,
struct AFSStoreStatus *as);
#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
extern int afs_setattr(OSI_VC_DECL(avc), register struct vattr *attrs,
extern int afs_setattr(OSI_VC_DECL(avc), struct vattr *attrs,
int flags, afs_ucred_t *acred);
#else
extern int afs_setattr(OSI_VC_DECL(avc), register struct vattr *attrs,
extern int afs_setattr(OSI_VC_DECL(avc), struct vattr *attrs,
afs_ucred_t *acred);
#endif
@ -1117,14 +1117,14 @@ extern int afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
enum vcexcl aexcl, int amode, struct vcache **avcp,
afs_ucred_t *acred);
#endif /* AFS_SGI64_ENV */
extern int afs_LocalHero(register struct vcache *avc,
register struct dcache *adc,
register AFSFetchStatus * astat, register int aincr);
extern int afs_LocalHero(struct vcache *avc,
struct dcache *adc,
AFSFetchStatus * astat, int aincr);
/* VNOPS/afs_vnop_dirops.c */
extern int afs_mkdir(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
register struct vcache **avcp, afs_ucred_t *acred);
struct vcache **avcp, afs_ucred_t *acred);
#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
extern int afs_rmdir(OSI_VC_DECL(adp), char *aname, struct vnode *cdirp,
afs_ucred_t *acred);
@ -1149,7 +1149,7 @@ extern afs_int32 lastWarnTime;
extern void lockIdSet(struct AFS_FLOCK *flock, struct SimpleLocks *slp,
int clid);
extern int HandleFlock(register struct vcache *avc, int acom,
extern int HandleFlock(struct vcache *avc, int acom,
struct vrequest *areq, pid_t clid, int onlymine);
#if defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
@ -1170,9 +1170,9 @@ extern int afs_link(struct vcache *avc, OSI_VC_DECL(adp), char *aname,
#endif
/* VNOPS/afs_vnop_lookup.c */
extern int EvalMountPoint(register struct vcache *avc, struct vcache *advc,
extern int EvalMountPoint(struct vcache *avc, struct vcache *advc,
struct volume **avolpp,
register struct vrequest *areq);
struct vrequest *areq);
extern void afs_InitFakeStat(struct afs_fakestat_state *state);
extern int afs_EvalFakeStat(struct vcache **avcp,
struct afs_fakestat_state *state,
@ -1181,10 +1181,10 @@ extern int afs_TryEvalFakeStat(struct vcache **avcp,
struct afs_fakestat_state *state,
struct vrequest *areq);
extern void afs_PutFakeStat(struct afs_fakestat_state *state);
extern int afs_ENameOK(register char *aname);
extern void Check_AtSys(register struct vcache *avc, const char *aname,
extern int afs_ENameOK(char *aname);
extern void Check_AtSys(struct vcache *avc, const char *aname,
struct sysname_info *state, struct vrequest *areq);
extern int Next_AtSys(register struct vcache *avc, struct vrequest *areq,
extern int Next_AtSys(struct vcache *avc, struct vrequest *areq,
struct sysname_info *state);
extern int afs_DoBulkStat(struct vcache *adp, long dirCookie,
struct vrequest *areqp);
@ -1212,10 +1212,10 @@ extern int afs_open(struct vcache **avcp, afs_int32 aflags,
/* VNOPS/afs_vnop_read.c */
extern int afs_MemRead(register struct vcache *avc, struct uio *auio,
extern int afs_MemRead(struct vcache *avc, struct uio *auio,
afs_ucred_t *acred, daddr_t albn,
struct buf **abpp, int noLock);
extern int afs_UFSRead(register struct vcache *avc, struct uio *auio,
extern int afs_UFSRead(struct vcache *avc, struct uio *auio,
afs_ucred_t *acred, daddr_t albn,
struct buf **abpp, int noLock);
extern void afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
@ -1236,10 +1236,10 @@ extern int afs_readdir(OSI_VC_DECL(avc), struct uio *auio,
#endif
/* VNOPS/afs_vnop_remove.c */
extern int afsremove(register struct vcache *adp, register struct dcache *tdc,
register struct vcache *tvc, char *aname,
extern int afsremove(struct vcache *adp, struct dcache *tdc,
struct vcache *tvc, char *aname,
afs_ucred_t *acred, struct vrequest *treqp);
extern int afs_remunlink(register struct vcache *avc, register int doit);
extern int afs_remunlink(struct vcache *avc, int doit);
extern int afs_remove(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred);
extern char *afs_newname(void);
@ -1258,15 +1258,15 @@ extern int afs_rename(OSI_VC_DECL(aodp), char *aname1, struct vcache *andp,
/* VNOPS/afs_vnop_strategy.c */
#if defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
extern int afs_ustrategy(register struct buf *adp, afs_ucred_t *credp);
extern int afs_ustrategy(struct buf *adp, afs_ucred_t *credp);
#else
extern int afs_ustrategy(register struct buf *adp);
extern int afs_ustrategy(struct buf *adp);
#endif
/* VNOPS/afs_vnop_symlink.c */
extern int afs_MemHandleLink(register struct vcache *avc,
extern int afs_MemHandleLink(struct vcache *avc,
struct vrequest *areq);
extern int afs_UFSHandleLink(register struct vcache *avc,
extern int afs_UFSHandleLink(struct vcache *avc,
struct vrequest *areq);
extern int afs_symlink(OSI_VC_DECL(adp), char *aname,
struct vattr *attrs, char *atargetName,
@ -1275,15 +1275,15 @@ extern int afs_readlink(OSI_VC_DECL(avc), struct uio *auio,
afs_ucred_t *acred);
/* VNOPS/afs_vnop_write.c */
extern int afs_MemWrite(register struct vcache *avc, struct uio *auio,
extern int afs_MemWrite(struct vcache *avc, struct uio *auio,
int aio, afs_ucred_t *acred, int noLock);
extern int afs_StoreOnLastReference(register struct vcache *avc,
register struct vrequest *treq);
extern int afs_UFSWrite(register struct vcache *avc, struct uio *auio,
extern int afs_StoreOnLastReference(struct vcache *avc,
struct vrequest *treq);
extern int afs_UFSWrite(struct vcache *avc, struct uio *auio,
int aio, afs_ucred_t *acred, int noLock);
extern int afs_DoPartialWrite(register struct vcache *avc,
extern int afs_DoPartialWrite(struct vcache *avc,
struct vrequest *areq);
extern int afs_closex(register struct file *afd);
extern int afs_closex(struct file *afd);
#ifdef AFS_SGI65_ENV
extern int afs_close(OSI_VC_DECL(avc), afs_int32 aflags,
@ -1337,7 +1337,7 @@ extern void afs_ResetVolumes(struct server *srvp);
extern struct volume *afs_GetVolume(struct VenusFid *afid,
struct vrequest *areq,
afs_int32 locktype);
extern struct volume *afs_GetVolumeByName(register char *aname,
extern struct volume *afs_GetVolumeByName(char *aname,
afs_int32 acell, int agood,
struct vrequest *areq,
afs_int32 locktype);

26
src/afs/afs_segments.c
View File

@ -36,14 +36,14 @@ afs_uint32 afs_stampValue = 0;
*/
static int
afs_StoreMini(register struct vcache *avc, struct vrequest *areq)
afs_StoreMini(struct vcache *avc, struct vrequest *areq)
{
register struct afs_conn *tc;
struct afs_conn *tc;
struct AFSStoreStatus InStatus;
struct AFSFetchStatus OutStatus;
struct AFSVolSync tsync;
register afs_int32 code;
register struct rx_call *tcall;
afs_int32 code;
struct rx_call *tcall;
afs_size_t tlen, xlen = 0;
XSTATS_DECLS;
AFS_STATCNT(afs_StoreMini);
@ -157,13 +157,13 @@ int afs_dvhack = 0;
int
afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq,
afs_StoreAllSegments(struct vcache *avc, struct vrequest *areq,
int sync)
{
register struct dcache *tdc;
register afs_int32 code = 0;
register afs_int32 index;
register afs_int32 origCBs, foreign = 0;
struct dcache *tdc;
afs_int32 code = 0;
afs_int32 index;
afs_int32 origCBs, foreign = 0;
int hash;
afs_hyper_t newDV, oldDV; /* DV when we start, and finish, respectively */
struct dcache **dcList;
@ -649,12 +649,12 @@ afs_ExtendSegments(struct vcache *avc, afs_size_t alen, struct vrequest *areq)
* held.
*/
int
afs_TruncateAllSegments(register struct vcache *avc, afs_size_t alen,
afs_TruncateAllSegments(struct vcache *avc, afs_size_t alen,
struct vrequest *areq, afs_ucred_t *acred)
{
register struct dcache *tdc;
register afs_int32 code;
register afs_int32 index;
struct dcache *tdc;
afs_int32 code;
afs_int32 index;
afs_size_t newSize;
int dcCount, dcPos;

22
src/afs/afs_server.c
View File

@ -130,8 +130,8 @@ GetUpDownStats(struct server *srv)
void
afs_MarkServerUpOrDown(struct srvAddr *sa, int a_isDown)
{
register struct server *a_serverP = sa->server;
register struct srvAddr *sap;
struct server *a_serverP = sa->server;
struct srvAddr *sap;
osi_timeval_t currTime, *currTimeP; /*Current time */
afs_int32 downTime; /*Computed downtime, in seconds */
struct afs_stats_SrvUpDownInfo *upDownP; /*Ptr to up/down info record */
@ -240,7 +240,7 @@ afs_MarkServerUpOrDown(struct srvAddr *sa, int a_isDown)
afs_int32
afs_ServerDown(struct srvAddr *sa)
{
register struct server *aserver = sa->server;
struct server *aserver = sa->server;
AFS_STATCNT(ServerDown);
if (aserver->flags & SRVR_ISDOWN || sa->sa_flags & SRVADDR_ISDOWN)
@ -260,9 +260,9 @@ afs_ServerDown(struct srvAddr *sa)
int
afs_HaveCallBacksFrom(struct server *aserver)
{
register afs_int32 now;
register int i;
register struct vcache *tvc;
afs_int32 now;
int i;
struct vcache *tvc;
AFS_STATCNT(HaveCallBacksFrom);
now = osi_Time(); /* for checking for expired callbacks */
@ -283,11 +283,11 @@ afs_HaveCallBacksFrom(struct server *aserver)
static void
CheckVLServer(register struct srvAddr *sa, struct vrequest *areq)
CheckVLServer(struct srvAddr *sa, struct vrequest *areq)
{
register struct server *aserver = sa->server;
register struct afs_conn *tc;
register afs_int32 code;
struct server *aserver = sa->server;
struct afs_conn *tc;
afs_int32 code;
AFS_STATCNT(CheckVLServer);
/* Ping dead servers to see if they're back */
@ -879,7 +879,7 @@ unsigned int
afs_random(void)
{
static afs_int32 state = 0;
register int i;
int i;
AFS_STATCNT(afs_random);
if (!state) {

18
src/afs/afs_syscall.c
View File

@ -174,8 +174,8 @@ copyin_afs_ioctl(caddr_t cmarg, struct afs_ioctl *dst)
*/
syscall(syscall, p1, p2, p3, p4, p5, p6)
{
register rval1 = 0, code;
register monster;
int rval1 = 0, code;
int monster;
int retval = 0;
#ifndef AFS_AIX41_ENV
extern lock_t kernel_lock;
@ -466,7 +466,7 @@ struct afssysa {
};
# endif
Afs_syscall(register struct afssysa *uap, rval_t * rvp)
Afs_syscall(struct afssysa *uap, rval_t * rvp)
{
int *retval = &rvp->r_val1;
#elif defined(AFS_DARWIN100_ENV)
@ -497,7 +497,7 @@ afs3_syscall(afs_proc_t *p, void *args, unsigned int *retval)
int
afs3_syscall(struct thread *p, void *args)
{
register struct a {
struct a {
long syscall;
long parm1;
long parm2;
@ -518,7 +518,7 @@ afs3_syscall(struct lwp *p, void *args)
int
afs3_syscall(afs_proc_t *p, void *args, long *retval)
{
register struct a {
struct a {
long syscall;
long parm1;
long parm2;
@ -554,7 +554,7 @@ afs_syscall(long syscall, long parm1, long parm2, long parm3, long parm4)
int
Afs_syscall()
{
register struct a {
struct a {
long syscall;
long parm1;
long parm2;
@ -567,7 +567,7 @@ Afs_syscall()
int
Afs_syscall()
{
register struct a {
struct a {
long syscall;
long parm1;
long parm2;
@ -585,7 +585,7 @@ Afs_syscall()
int *retval = &u.u_rval1;
# endif
#endif
register int code = 0;
int code = 0;
AFS_STATCNT(afs_syscall);
#ifdef AFS_SUN5_ENV
@ -709,7 +709,7 @@ Afs_syscall()
} else if (uap->syscall == AFSCALL_SETPAG) {
#endif
#ifdef AFS_SUN5_ENV
register proc_t *procp;
proc_t *procp;
procp = ttoproc(curthread);
AFS_GLOCK();

52
src/afs/afs_user.c
View File

@ -58,12 +58,12 @@ void afs_ResetAccessCache(afs_int32 uid, int alock);
* appropriate conn structures for au
*/
static void
RemoveUserConns(register struct unixuser *au)
RemoveUserConns(struct unixuser *au)
{
register int i;
register struct server *ts;
register struct srvAddr *sa;
register struct afs_conn *tc, **lc;
int i;
struct server *ts;
struct srvAddr *sa;
struct afs_conn *tc, **lc;
AFS_STATCNT(RemoveUserConns);
for (i = 0; i < NSERVERS; i++) {
@ -98,8 +98,8 @@ RemoveUserConns(register struct unixuser *au)
void
afs_GCUserData(int aforce)
{
register struct unixuser *tu, **lu, *nu;
register int i;
struct unixuser *tu, **lu, *nu;
int i;
afs_int32 now, delFlag;
AFS_STATCNT(afs_GCUserData);
@ -163,8 +163,8 @@ afs_GCUserData(int aforce)
void
afs_CheckTokenCache(void)
{
register int i;
register struct unixuser *tu;
int i;
struct unixuser *tu;
afs_int32 now;
AFS_STATCNT(afs_CheckCacheResets);
@ -173,7 +173,7 @@ afs_CheckTokenCache(void)
now = osi_Time();
for (i = 0; i < NUSERS; i++) {
for (tu = afs_users[i]; tu; tu = tu->next) {
register afs_int32 uid;
afs_int32 uid;
/*
* If tokens are still good and user has Kerberos tickets,
@ -210,8 +210,8 @@ afs_CheckTokenCache(void)
void
afs_ResetAccessCache(afs_int32 uid, int alock)
{
register int i;
register struct vcache *tvc;
int i;
struct vcache *tvc;
struct axscache *ac;
AFS_STATCNT(afs_ResetAccessCache);
@ -237,7 +237,7 @@ afs_ResetAccessCache(afs_int32 uid, int alock)
* access info.
*/
void
afs_ResetUserConns(register struct unixuser *auser)
afs_ResetUserConns(struct unixuser *auser)
{
int i;
struct srvAddr *sa;
@ -268,8 +268,8 @@ afs_ResetUserConns(register struct unixuser *auser)
struct unixuser *
afs_FindUser(afs_int32 auid, afs_int32 acell, afs_int32 locktype)
{
register struct unixuser *tu;
register afs_int32 i;
struct unixuser *tu;
afs_int32 i;
AFS_STATCNT(afs_FindUser);
i = UHash(auid);
@ -312,9 +312,9 @@ afs_FindUser(afs_int32 auid, afs_int32 acell, afs_int32 locktype)
void
afs_ComputePAGStats(void)
{
register struct unixuser *currPAGP; /*Ptr to curr PAG */
register struct unixuser *cmpPAGP; /*Ptr to PAG being compared */
register struct afs_stats_AuthentInfo *authP; /*Ptr to stats area */
struct unixuser *currPAGP; /*Ptr to curr PAG */
struct unixuser *cmpPAGP; /*Ptr to PAG being compared */
struct afs_stats_AuthentInfo *authP; /*Ptr to stats area */
int curr_Record; /*Curr record */
int currChain; /*Curr hash chain */
int currChainLen; /*Length of curr hash chain */
@ -445,11 +445,11 @@ afs_ComputePAGStats(void)
struct unixuser *
afs_GetUser(register afs_int32 auid, afs_int32 acell, afs_int32 locktype)
afs_GetUser(afs_int32 auid, afs_int32 acell, afs_int32 locktype)
{
register struct unixuser *tu, *pu = 0;
register afs_int32 i;
register afs_int32 RmtUser = 0;
struct unixuser *tu, *pu = 0;
afs_int32 i;
afs_int32 RmtUser = 0;
AFS_STATCNT(afs_GetUser);
i = UHash(auid);
@ -506,7 +506,7 @@ afs_GetUser(register afs_int32 auid, afs_int32 acell, afs_int32 locktype)
void
afs_PutUser(register struct unixuser *au, afs_int32 locktype)
afs_PutUser(struct unixuser *au, afs_int32 locktype)
{
AFS_STATCNT(afs_PutUser);
--au->refCount;
@ -518,10 +518,10 @@ afs_PutUser(register struct unixuser *au, afs_int32 locktype)
* dude has the flag set at any time for a particular unix uid.
*/
void
afs_SetPrimary(register struct unixuser *au, register int aflag)
afs_SetPrimary(struct unixuser *au, int aflag)
{
register struct unixuser *tu;
register int i;
struct unixuser *tu;
int i;
struct unixuser *pu;
AFS_STATCNT(afs_SetPrimary);

12
src/afs/afs_util.c
View File

@ -59,8 +59,8 @@ afs_int32 afs_new_inum = 0;
char *
afs_cv2string(char *ttp, afs_uint32 aval)
{
register char *tp = ttp;
register int i;
char *tp = ttp;
int i;
int any;
AFS_STATCNT(afs_cv2string);
@ -198,7 +198,7 @@ void
print_internet_address(char *preamble, struct srvAddr *sa, char *postamble,
int flag)
{
register struct server *aserver = sa->server;
struct server *aserver = sa->server;
char *ptr = "\n";
afs_uint32 address;
@ -231,13 +231,13 @@ print_internet_address(char *preamble, struct srvAddr *sa, char *postamble,
void
afs_CheckLocks(void)
{
register int i;
int i;
afs_warn("Looking for locked data structures.\n");
afs_warn("conn %p, volume %p, user %p, cell %p, server %p\n", &afs_xconn,
&afs_xvolume, &afs_xuser, &afs_xcell, &afs_xserver);
{
register struct vcache *tvc;
struct vcache *tvc;
AFS_STATCNT(afs_CheckLocks);
for (i = 0; i < VCSIZE; i++) {
@ -255,7 +255,7 @@ afs_CheckLocks(void)
}
}
{
register struct dcache *tdc;
struct dcache *tdc;
for (i = 0; i < afs_cacheFiles; i++) {
tdc = afs_indexTable[i];
if (tdc) {

66
src/afs/afs_vcache.c
View File

@ -297,7 +297,7 @@ static struct afs_cbr *afs_cbrHeads[16];
struct afs_cbr *
afs_AllocCBR(void)
{
register struct afs_cbr *tsp;
struct afs_cbr *tsp;
int i;
if (!afs_cbrSpace) {
@ -341,7 +341,7 @@ afs_AllocCBR(void)
* \rerurn 0
*/
int
afs_FreeCBR(register struct afs_cbr *asp)
afs_FreeCBR(struct afs_cbr *asp)
{
*(asp->pprev) = asp->next;
if (asp->next)
@ -897,12 +897,12 @@ afs_NewBulkVCache(struct VenusFid *afid, struct server *serverp, int seq)
* \param doflocks : Do we handle flocks?
*/
void
afs_FlushActiveVcaches(register afs_int32 doflocks)
afs_FlushActiveVcaches(afs_int32 doflocks)
{
register struct vcache *tvc;
register int i;
register struct afs_conn *tc;
register afs_int32 code;
struct vcache *tvc;
int i;
struct afs_conn *tc;
afs_int32 code;
afs_ucred_t *cred = NULL;
struct vrequest treq, ureq;
struct AFSVolSync tsync;
@ -1076,7 +1076,7 @@ afs_FlushActiveVcaches(register afs_int32 doflocks)
int
afs_VerifyVCache2(struct vcache *avc, struct vrequest *areq)
{
register struct vcache *tvc;
struct vcache *tvc;
AFS_STATCNT(afs_VerifyVCache);
@ -1124,8 +1124,8 @@ afs_VerifyVCache2(struct vcache *avc, struct vrequest *areq)
*
*/
static void
afs_SimpleVStat(register struct vcache *avc,
register struct AFSFetchStatus *astat, struct vrequest *areq)
afs_SimpleVStat(struct vcache *avc,
struct AFSFetchStatus *astat, struct vrequest *areq)
{
afs_size_t length;
AFS_STATCNT(afs_SimpleVStat);
@ -1217,8 +1217,8 @@ afs_SimpleVStat(register struct vcache *avc,
*/
int
afs_WriteVCache(register struct vcache *avc,
register struct AFSStoreStatus *astatus,
afs_WriteVCache(struct vcache *avc,
struct AFSStoreStatus *astatus,
struct vrequest *areq)
{
afs_int32 code;
@ -1280,8 +1280,8 @@ afs_WriteVCache(register struct vcache *avc,
* \note Must be called with a shared lock on the vnode
*/
int
afs_WriteVCacheDiscon(register struct vcache *avc,
register struct AFSStoreStatus *astatus,
afs_WriteVCacheDiscon(struct vcache *avc,
struct AFSStoreStatus *astatus,
struct vattr *attrs)
{
afs_int32 code = 0;
@ -1361,8 +1361,8 @@ afs_WriteVCacheDiscon(register struct vcache *avc,
* \param areq Ptr to associated request.
*/
void
afs_ProcessFS(register struct vcache *avc,
register struct AFSFetchStatus *astat, struct vrequest *areq)
afs_ProcessFS(struct vcache *avc,
struct AFSFetchStatus *astat, struct vrequest *areq)
{
afs_size_t length;
AFS_STATCNT(afs_ProcessFS);
@ -1458,7 +1458,7 @@ afs_ProcessFS(register struct vcache *avc,
* \return Success status of operation.
*/
int
afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq,
afs_RemoteLookup(struct VenusFid *afid, struct vrequest *areq,
char *name, struct VenusFid *nfid,
struct AFSFetchStatus *OutStatusp,
struct AFSCallBack *CallBackp, struct server **serverp,
@ -1466,7 +1466,7 @@ afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq,
{
afs_int32 code;
afs_uint32 start;
register struct afs_conn *tc;
struct afs_conn *tc;
struct AFSFetchStatus OutDirStatus;
XSTATS_DECLS;
if (!name)
@ -1530,12 +1530,12 @@ afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq,
* already be held by the caller
*/
struct vcache *
afs_GetVCache(register struct VenusFid *afid, struct vrequest *areq,
afs_GetVCache(struct VenusFid *afid, struct vrequest *areq,
afs_int32 * cached, struct vcache *avc)
{
afs_int32 code, newvcache = 0;
register struct vcache *tvc;
struct vcache *tvc;
struct volume *tvp;
afs_int32 retry;
@ -1779,7 +1779,7 @@ afs_LookupVCache(struct VenusFid *afid, struct vrequest *areq,
{
afs_int32 code, now, newvcache = 0;
struct VenusFid nfid;
register struct vcache *tvc;
struct vcache *tvc;
struct volume *tvp;
struct AFSFetchStatus OutStatus;
struct AFSCallBack CallBack;
@ -1953,7 +1953,7 @@ afs_GetRootVCache(struct VenusFid *afid, struct vrequest *areq,
afs_int32 getNewFid = 0;
afs_uint32 start;
struct VenusFid nfid;
register struct vcache *tvc;
struct vcache *tvc;
struct server *serverp = 0;
struct AFSFetchStatus OutStatus;
struct AFSCallBack CallBack;
@ -2250,7 +2250,7 @@ afs_FetchStatus(struct vcache * avc, struct VenusFid * afid,
{
int code;
afs_uint32 start = 0;
register struct afs_conn *tc;
struct afs_conn *tc;
struct AFSCallBack CallBack;
struct AFSVolSync tsync;
XSTATS_DECLS;
@ -2313,13 +2313,13 @@ afs_FetchStatus(struct vcache * avc, struct VenusFid * afid,
* Nothing interesting.
*/
void
afs_StuffVcache(register struct VenusFid *afid,
afs_StuffVcache(struct VenusFid *afid,
struct AFSFetchStatus *OutStatus,
struct AFSCallBack *CallBack, register struct afs_conn *tc,
struct AFSCallBack *CallBack, struct afs_conn *tc,
struct vrequest *areq)
{
register afs_int32 code, i, newvcache = 0;
register struct vcache *tvc;
afs_int32 code, i, newvcache = 0;
struct vcache *tvc;
struct AFSVolSync tsync;
struct volume *tvp;
struct axscache *ac;
@ -2447,7 +2447,7 @@ afs_StuffVcache(register struct VenusFid *afid,
* \note Environment: Nothing interesting.
*/
void
afs_PutVCache(register struct vcache *avc)
afs_PutVCache(struct vcache *avc)
{
AFS_STATCNT(afs_PutVCache);
#ifdef AFS_DARWIN80_ENV
@ -2588,7 +2588,7 @@ struct vcache *
afs_FindVCache(struct VenusFid *afid, afs_int32 * retry, afs_int32 flag)
{
register struct vcache *tvc;
struct vcache *tvc;
afs_int32 i;
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
@ -2716,7 +2716,7 @@ int afs_duplicate_nfs_fids = 0;
afs_int32
afs_NFSFindVCache(struct vcache **avcp, struct VenusFid *afid)
{
register struct vcache *tvc;
struct vcache *tvc;
afs_int32 i;
afs_int32 count = 0;
struct vcache *found_tvc = NULL;
@ -2857,7 +2857,7 @@ void
afs_vcacheInit(int astatSize)
{
#if !defined(AFS_LINUX22_ENV)
register struct vcache *tvp;
struct vcache *tvp;
#endif
int i;
if (!afs_maxvcount) {
@ -2924,8 +2924,8 @@ shutdown_vcache(void)
*/
{
register struct afs_q *tq, *uq = NULL;
register struct vcache *tvc;
struct afs_q *tq, *uq = NULL;
struct vcache *tvc;
for (tq = VLRU.prev; tq != &VLRU; tq = uq) {
tvc = QTOV(tq);
uq = QPrev(tq);

26
src/afs/afs_volume.c
View File

@ -79,10 +79,10 @@ static int inVolList(struct VenusFid *fid, afs_int32 nvols, afs_int32 * vID,
* @return return 0 if can't parse as a number.
*/
static int
afs_vtoi(register char *aname)
afs_vtoi(char *aname)
{
register afs_int32 temp;
register int tc;
afs_int32 temp;
int tc;
temp = 0;
AFS_STATCNT(afs_vtoi);
while ((tc = *aname++)) {
@ -113,9 +113,9 @@ afs_int32 afs_FVIndex = -1;
struct volume *
afs_UFSGetVolSlot(void)
{
register struct volume *tv = NULL, **lv;
struct volume *tv = NULL, **lv;
struct osi_file *tfile;
register afs_int32 i = -1, code;
afs_int32 i = -1, code;
afs_int32 bestTime;
struct volume *bestVp, *oldLp = NULL, **bestLp = NULL;
char *oldname = NULL;
@ -239,7 +239,7 @@ afs_UFSGetVolSlot(void)
struct volume *
afs_MemGetVolSlot(void)
{
register struct volume *tv;
struct volume *tv;
AFS_STATCNT(afs_MemGetVolSlot);
if (!afs_freeVolList) {
@ -653,7 +653,7 @@ afs_SetupVolume(afs_int32 volid, char *aname, void *ve, struct cell *tcell,
* @return
*/
struct volume *
afs_GetVolumeByName(register char *aname, afs_int32 acell, int agood,
afs_GetVolumeByName(char *aname, afs_int32 acell, int agood,
struct vrequest *areq, afs_int32 locktype)
{
afs_int32 i;
@ -882,9 +882,9 @@ afs_NewVolumeByName(char *aname, afs_int32 acell, int agood,
void
InstallVolumeEntry(struct volume *av, struct vldbentry *ve, int acell)
{
register struct server *ts;
struct server *ts;
struct cell *cellp;
register int i, j;
int i, j;
afs_int32 mask;
afs_uint32 temp;
@ -960,9 +960,9 @@ InstallVolumeEntry(struct volume *av, struct vldbentry *ve, int acell)
void
InstallNVolumeEntry(struct volume *av, struct nvldbentry *ve, int acell)
{
register struct server *ts;
struct server *ts;
struct cell *cellp;
register int i, j;
int i, j;
afs_int32 mask;
afs_uint32 temp;
@ -1038,10 +1038,10 @@ void
InstallUVolumeEntry(struct volume *av, struct uvldbentry *ve, int acell,
struct cell *tcell, struct vrequest *areq)
{
register struct server *ts;
struct server *ts;
struct afs_conn *tconn;
struct cell *cellp;
register int i, j;
int i, j;
afs_uint32 serverid;
afs_int32 mask;
int k;

4
src/afs/discon.h
View File

@ -17,8 +17,8 @@ extern afs_int32 afs_ConflictPolicy;
extern afs_uint32 afs_DisconVnode; /* XXX: not protected. */
extern int afs_WriteVCacheDiscon(register struct vcache *avc,
register struct AFSStoreStatus *astatus,
extern int afs_WriteVCacheDiscon(struct vcache *avc,
struct AFSStoreStatus *astatus,
struct vattr *attrs);
extern int afs_ResyncDisconFiles(struct vrequest *areq,
afs_ucred_t *acred);

4
src/afsweb/apache_afs_cache.c
View File

@ -469,7 +469,7 @@ getTokenLen(char *buf)
afs_int32 len = 0;
afs_int32 rc = 0;
char cellName[WEBLOG_CELLNAME_MAX];
register char *tp;
char *tp;
int n = sizeof(afs_int32);
struct ClearToken {
afs_int32 AuthHandle;
@ -505,7 +505,7 @@ long
getExpiration(char *buf)
{
afs_int32 len = 0;
register char *tp;
char *tp;
int n = sizeof(afs_int32);
struct ClearToken {
afs_int32 AuthHandle;

2
src/afsweb/apache_afs_client.c
View File

@ -375,7 +375,7 @@ request_Authentication(char *user, char *passwd, char *cell, char *type,
static int
setToken(char *tokenBuf, int tokenLen)
{
register char *temp;
char *temp;
afs_int32 i = 0;
afsassert(tokenBuf);

2
src/afsweb/apache_afs_utils.c
View File

@ -191,7 +191,7 @@ parseToken(char *buf)
{
afs_int32 len = 0;
char cellName[64];
register char *tp;
char *tp;
struct ClearToken {
afs_int32 AuthHandle;

4
src/aklog/asetkey.c
View File

@ -55,7 +55,7 @@ int
main(int argc, char *argv[])
{
struct afsconf_dir *tdir;
register long code;
long code;
const char *confdir;
if (argc == 1) {
@ -173,7 +173,7 @@ main(int argc, char *argv[])
}
else if (strcmp(argv[1], "list") == 0) {
struct afsconf_keys tkeys;
register int i, j;
int i, j;
code = afsconf_GetKeys(tdir, &tkeys);
if (code) {

2
src/aklog/klog.c
View File

@ -160,7 +160,7 @@ getpipepass(void)
{
static char gpbuf[BUFSIZ];
/* read a password from stdin, stop on \n or eof */
register int i, tc;
int i, tc;
memset(gpbuf, 0, sizeof(gpbuf));
for (i = 0; i < (sizeof(gpbuf) - 1); i++) {
tc = fgetc(stdin);

Some files were not shown because too many files have changed in this diff Show More