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>
}
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);
*/
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) {
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;
}
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);
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
}
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);
/* 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);
/**
/* 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");
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;
int *perror;
{
struct inode *ip;
- register was_locked;
+ int was_locked;
struct vfs *nvfsp = NULL;
int code;
*perror = 0;
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;
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;
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;
{
struct uio uio_struct;
struct iovec uiovector;
- register int code;
+ int code;
AFS_STATCNT(gop_rdwr);
/* Set up the uio structure */
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;
afs_suser(void *credp)
{
- register rc;
+ int rc;
char err;
rc = suser(&err);
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;
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:
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);
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;
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()
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)) {
{
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;
}
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);
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
}
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);
/* 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
/* 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
{
vnode_t pvp, vp;
extern struct osi_dev cacheDev;
- register int code = 0;
+ int code = 0;
*perror = 0;
*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 {
{
struct vnode *pvp, *vp;
extern struct osi_dev cacheDev;
- register int code = 0;
+ int code = 0;
*perror = 0;
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;
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;
{
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;
* 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;
* 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;
{
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 */
* } */ *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) {
* } */ *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();
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);
* 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;
* } */ *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) {
* 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. */
* 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)
{
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());
* 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);
* 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,
}
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);
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
}
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);
/* 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);
/**
/* 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");
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;
*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)
int *perror;
{
struct inode *ip;
- register int code = 0;
+ int code = 0;
*perror = 0;
{
int dummy, err = 0;
struct inode *ip, *newip;
- register int code;
+ int code;
struct vnode *vp;
AFS_STATCNT(afs_syscall_icreate);
int dummy;
int fd;
extern struct fileops vnops;
- register int code;
+ int code;
AFS_STATCNT(afs_syscall_iopen);
{
int dummy;
struct inode *ip;
- register int code;
+ int code;
if (!afs_suser(NULL))
return (EPERM);
{
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
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;
{
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();
* } */ *ap;
{
int error;
- register struct vnode *vp = ap->a_vp;
+ struct vnode *vp = ap->a_vp;
AFS_GLOCK();
/*vflushbuf(vp, wait); */
* } */ *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();
* } */ *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();
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;
/*
* 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;
* } */ *ap;
{
int error = 0;
- register struct vnode *dvp = ap->a_dvp;
+ struct vnode *dvp = ap->a_dvp;
GETNAME();
AFS_GLOCK();
* 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);
* 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,
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;
}
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);
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
}
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);
/* 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);
/**
/* 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");
void
afs_osi_TraverseProcTable(void)
{
- register proc_t *p;
+ proc_t *p;
int endchain = 0;
MP_SPINLOCK(activeproc_lock);
struct ucred *newcr;
ulong_t s;
#if defined(AFS_HPUX110_ENV)
- register ulong_t context;
+ ulong_t context;
#endif
AFS_STATCNT(afs_setgroups);
{
struct inode *pip, *ip;
extern struct osi_dev cacheDev;
- register int code = 0;
+ int code = 0;
*perror = 0;
AFS_STATCNT(igetinode);
struct vnode *vp = NULL;
int dummy;
extern struct fileops vnodefops;
- register int code;
+ int code;
int fd;
AFS_STATCNT(afs_syscall_iopen);
{
int dummy;
struct inode *ip;
- register afs_int32 code;
+ afs_int32 code;
if (!afs_suser(NULL)) {
u.u_error = EPERM;
#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)
/* 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;
/* 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);
{
int code = 0;
struct vrequest treq;
- register struct vcache *tvp = 0;
+ struct vcache *tvp = 0;
AFS_GLOCK();
AFS_STATCNT(afs_root);
}
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);
void
osi_InitGlock()
{
- register ulong_t context;
+ ulong_t context;
SPINLOCK_USAV(sched_lock, context);
if (!afs_Starting) {
*/
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");
afs_bmap(avc, abn, anvp, anbn)
- register struct vcache *avc;
+ struct vcache *avc;
kern_daddr_t abn, *anbn;
struct vcache **anvp;
{
}
afs_inactive(avc, acred)
- register struct vcache *avc;
+ struct vcache *avc;
afs_ucred_t *acred;
{
struct vnode *vp = AFSTOV(avc);
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);
}
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);
}
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();
}
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);
}
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);
}
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);
}
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);
}
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);
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);
}
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);
}
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);
}
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);
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);
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);
}
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);
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);
}
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);
}
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);
}
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);
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);
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);
int
mp_afs_fid(struct vnode *avc, struct fid **fidpp)
{
- register int code;
+ int code;
AFS_GLOCK();
code = afs_fid(avc, 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);
* 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);
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);
/*
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;
}
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);
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
}
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);
/* 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);
/**
/* 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");
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;
* 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) {
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' */
#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) { \
#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) { \
#define AFS_GUNLOCK()
#define ISAFS_GLOCK() 1
-#define SPLVAR register int splvar
+#define SPLVAR int splvar
#define NETPRI splvar=splnet()
#define USERPRI splx(splvar)
{
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);
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);
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);
{
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)
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);
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)
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;
{
OSI_VC_CONVERT(avc);
struct vnode *vp = AFSTOV(avc);
- register struct brequest *tb;
+ struct brequest *tb;
struct vrequest treq;
afs_int32 code;
}
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);
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (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);
/* 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;
/* 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;
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;
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)) {
{
struct vcache *avc = VTOAFS(FILE_INODE(fp));
struct vrequest treq;
- register struct dcache *tdc;
+ struct dcache *tdc;
int code;
int offset;
int dirpos;
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;
}
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));
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (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);
/* 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;
/* 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;
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;
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)) {
{
struct vcache *avc = VTOAFS(FILE_INODE(fp));
struct vrequest treq;
- register struct dcache *tdc;
+ struct dcache *tdc;
int code;
int offset;
int dirpos;
int
afs_mount(mp, path, data, ndp, p)
- register struct mount *mp;
+ struct mount *mp;
char *path;
caddr_t data;
struct nameidata *ndp;
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));
#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
}
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);
}
int
-osi_UFSClose(register struct osi_file *afile)
+osi_UFSClose(struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
}
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);
/* 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;
#else
int resid;
#endif
- register afs_int32 code;
- register afs_int32 cnt1 = 0;
+ afs_int32 code;
+ afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
/* 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;
#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");
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;
int *perror;
{
struct inode *ip;
- register afs_int32 code;
+ afs_int32 code;
struct vnode *vp;
struct fs *fs;
struct inode *pip;
{
struct inode *pip, *ip;
extern struct osi_dev cacheDev;
- register int code = 0;
+ int code = 0;
*perror = 0;
{
int dummy, err = 0;
struct inode *ip, *newip;
- register int code;
+ int code;
dev_t newdev;
struct ufsvfs *ufsvfsp;
struct vnode *vp = NULL;
int dummy;
int fd;
- register int code;
+ int code;
dev_t newdev;
AFS_STATCNT(afs_syscall_iopen);
{
int dummy;
struct inode *ip;
- register afs_int32 code;
+ afs_int32 code;
dev_t newdev;
if (!afs_osi_suser(credp))
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;
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)
{
}
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)
{
#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");
#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");
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 */
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;
}
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;
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);
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);
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
offset_t off, afs_ucred_t *credp)
#endif
{
- register afs_int32 code = 0;
+ afs_int32 code = 0;
/*
* Implement based on afs_lockctl
*/
offset_t off, afs_ucred_t *credp)
#endif
{
- register afs_int32 code = EINVAL;
+ afs_int32 code = EINVAL;
struct vattr vattr;
if ((cmd == F_FREESP)
#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)
#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);
}
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);
}
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);
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);
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);
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);
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);
}
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);
}
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);
}
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);
}
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);
}
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);
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);
}
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);
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);
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
}
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);
int
gafs_fid(struct vcache *avc, struct fid **fidpp)
{
- register int code;
+ int code;
AFS_GLOCK();
code = afs_fid(avc, fidpp);
}
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)
}
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);
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);
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);
}
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;
/* 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 */
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);
#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);
* 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);
/* 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);
}
}
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;
/* 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)
*/
#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);
{
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;
* 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);
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;
#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;
{
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;
/* 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);
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
*/
/* 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;
static void
DoLockWarning(afs_ucred_t * acred)
{
- register afs_int32 now;
+ afs_int32 now;
pid_t pid = MyPidxx2Pid(MyPidxx);
char *procname;
* 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);
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;
#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;
*/
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)
{
}
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;
}
int
-afs_ENameOK(register char *aname)
+afs_ENameOK(char *aname)
{
- register int tlen;
+ int tlen;
AFS_STATCNT(ENameOK);
tlen = strlen(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);
}
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;
}
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;
/* 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++)
} 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;
{
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;
}
{ /* sub-block just to reduce stack usage */
- register struct dcache *tdc;
+ struct dcache *tdc;
afs_size_t dirOffset, dirLen;
struct VenusFid tfid;
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;
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);
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)
{
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 */
}
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)
{
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 */
#endif
{
struct vrequest treq;
- register struct dcache *tdc;
+ struct dcache *tdc;
afs_size_t origOffset, tlen;
afs_int32 len;
int code = 0;
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;
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);
}
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;
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);
* 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))
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;
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;
#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)
}
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
}
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
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);
* 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;
}
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;
afs_int32 tlen, trimlen;
afs_int32 startDate;
afs_int32 max;
- register struct dcache *tdc;
+ struct dcache *tdc;
#ifdef _HIGHC_
volatile
#endif
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);
/* 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;
afs_int32 trimlen;
afs_int32 startDate;
afs_int32 max;
- register struct dcache *tdc;
+ struct dcache *tdc;
#ifdef _HIGHC_
volatile
#endif
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);
/* 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
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;
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);
* 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;
struct axscache *
afs_SlowFindAxs(struct axscache **cachep, afs_int32 id)
{
- register struct axscache *i, *j;
+ struct axscache *i, *j;
j = (*cachep);
i = j->next;
/* 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)
}
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;
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)) {
}
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);
/* 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);
{
/* 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)
}
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 */
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);
DFlush(void)
{
/* Flush all the modified buffers. */
- register int i;
- register struct buffer *tb;
+ int i;
+ struct buffer *tb;
AFS_STATCNT(DFlush);
tb = Buffers;
}
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) {
void
shutdown_bufferpackage(void)
{
- register struct buffer *tp;
+ struct buffer *tp;
int i;
AFS_STATCNT(shutdown_bufferpackage);
* 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;
* 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;
/* 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)
{
/* 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;
/* 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;
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 {
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
/* 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);
int
afs_CheckInit(void)
{
- register int code = 0;
+ int code = 0;
AFS_STATCNT(afs_CheckInit);
if (afs_initState <= 100)
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;
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;
*------------------------------------------------------------------------*/
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
*------------------------------------------------------------------------*/
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;
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;
/* 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) {
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;
{ /*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;
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();
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 */
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 */
void
afs_InitCBQueue(int doLockInit)
{
- register int i;
+ int i;
memset(cbHashT, 0, CBHTSIZE * sizeof(struct bucket));
for (i = 0; i < CBHTSIZE; i++) {
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. */
* @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;
*/
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);
* @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--;
/* 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
* 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;
#if defined(AFS_CACHE_BYPASS)
static void
-BPrefetchNoCache(register struct brequest *ab)
+BPrefetchNoCache(struct brequest *ab)
{
struct vrequest treq;
afs_size_t len;
#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;
/* release a held request buffer */
void
-afs_BRelease(register struct brequest *ab)
+afs_BRelease(struct brequest *ab)
{
AFS_STATCNT(afs_BRelease);
}
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);
*/
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";
*/
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);
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 */
* (in write mode).
*/
void
-afs_FlushDCache(register struct dcache *adc)
+afs_FlushDCache(struct dcache *adc)
{
AFS_STATCNT(afs_FlushDCache);
/*
* \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
*/
static void
-afs_DiscardDCache(register struct dcache *adc)
+afs_DiscardDCache(struct dcache *adc)
{
- register afs_int32 size;
+ afs_int32 size;
AFS_STATCNT(afs_DiscardDCache);
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);
* Nothing interesting.
*/
int
-afs_PutDCache(register struct dcache *adc)
+afs_PutDCache(struct dcache *adc)
{
AFS_STATCNT(afs_PutDCache);
ObtainWriteLock(&adc->tlock, 276);
* 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));
*/
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);
/* 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;
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;
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;
*/
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);
* 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;
*/
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;
* 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++) {
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;
void
afs_dcacheInit(int afiles, int ablocks, int aDentries, int achunk, int aflags)
{
- register struct dcache *tdp;
+ struct dcache *tdp;
int i;
int code;
}
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);
}
void
-afs_FinalizeReq(register struct vrequest *areq)
+afs_FinalizeReq(struct vrequest *areq)
{
int i = 0;
AFS_STATCNT(afs_FinalizeReq);
#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 */
#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)
/* 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 */
* 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,
}
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,
* 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 */
{
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]);
*/
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;
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);
* 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)
{
/* 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++;
/* 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;
/* 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) {
/* 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) {
/* 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) {
/* 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) {
/* 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)) {
/* 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! */
/* 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;
/* 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;
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) {
(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);
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);
/* 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++;
/* 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) {
/* 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)) {
/* 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;
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) {
int
afs_icl_ZeroSet(struct afs_icl_set *setp)
{
- register int i;
+ int i;
int code = 0;
int tcode;
struct afs_icl_log *logp;
(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);
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);
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);
/*
void
afs_ComputeCacheParms(void)
{
- register afs_int32 i;
+ afs_int32 i;
afs_int32 afs_maxCacheDirty;
/*
*
*/
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;
int
afs_ResourceInit(int preallocs)
{
- register afs_int32 i;
+ afs_int32 i;
static struct rx_securityClass *secobj;
AFS_STATCNT(afs_ResourceInit);
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);
}
\f
void
-ObtainLock(register struct afs_lock *lock, int how,
+ObtainLock(struct afs_lock *lock, int how,
unsigned int src_indicator)
{
switch (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) {
}
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;
/* 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();
/* 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();
/*
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;
/* 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);
/* 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);
/* 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);
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++;
}
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) {
}
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);
* 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);
* 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;
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;
}
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;
/*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;
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;
}
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);
void
shutdown_memcache(void)
{
- register int index;
+ int index;
if (cacheDiskType != AFS_FCACHE_TYPE_MEM)
return;
/* 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());
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());
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());
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();
/* 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());
/* 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;
/* 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;
* 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)
* "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)
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 */
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;
/* 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;
}
#else
{
- register int s;
+ int s;
s = splclock();
time = *atv;
(void)splx(s);
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);
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
void *
osi_AllocLargeSpace(size_t size)
{
- register struct osi_packet *tp;
+ struct osi_packet *tp;
AFS_ASSERT_GLOCK();
void *
osi_AllocSmallSpace(size_t size)
{
- register struct osi_packet *tp;
+ struct osi_packet *tp;
AFS_STATCNT(osi_AllocSmallSpace);
if (size > AFS_SMALLOCSIZ)
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;
/* 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)
/* 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;
/* 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
{
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);
#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)
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;
* 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 */
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);
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;
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);
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);
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) {
# 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;
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);
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)
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);
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;
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);
};
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)))
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);
# 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;
};
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);
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);
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);
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);
#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! */
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;
DECL_PIOCTL(PSetAcl)
{
- register afs_int32 code;
+ afs_int32 code;
struct afs_conn *tconn;
struct AFSOpaque acl;
struct AFSVolSync tsync;
*/
DECL_PIOCTL(PGetFileCell)
{
- register struct cell *tcell;
+ struct cell *tcell;
AFS_STATCNT(PGetFileCell);
if (!avc)
*/
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 */
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;
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;
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);
*/
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;
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;
*/
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 */
*/
DECL_PIOCTL(PCheckServers)
{
- register int i;
- register struct server *ts;
+ int i;
+ struct server *ts;
afs_int32 temp;
char *cellName = NULL;
struct cell *cellp;
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
*/
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);
*/
DECL_PIOCTL(PViceAccess)
{
- register afs_int32 code;
+ afs_int32 code;
afs_int32 temp;
AFS_STATCNT(PViceAccess);
{
afs_int32 results[MAXGCSTATS];
afs_int32 flags;
- register struct dcache * tdc;
+ struct dcache * tdc;
int i, size;
AFS_STATCNT(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;
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);
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 */
*/
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;
*/
DECL_PIOCTL(PGetCellStatus)
{
- register struct cell *tcell;
+ struct cell *tcell;
char *cellName;
afs_int32 temp;
*/
DECL_PIOCTL(PSetCellStatus)
{
- register struct cell *tcell;
+ struct cell *tcell;
char *cellName;
afs_int32 flags0, flags1;
*/
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
*/
DECL_PIOCTL(PGetVnodeXStatus)
{
- register afs_int32 code;
+ afs_int32 code;
struct vcxstat stat;
afs_int32 mode, i;
DECL_PIOCTL(PGetVnodeXStatus2)
{
- register afs_int32 code;
+ afs_int32 code;
struct vcxstat2 stat;
afs_int32 mode;
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;
{
int i;
struct volume *j;
- register int k;
+ int k;
if (vlonly) {
afs_int32 *p;
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)
*/
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;
DECL_PIOCTL(PPrefetchFromTape)
{
- register afs_int32 code, code1;
+ afs_int32 code, code1;
afs_int32 bytes, outval;
struct afs_conn *tc;
struct rx_call *tcall;
DECL_PIOCTL(PFsCmd)
{
- register afs_int32 code;
+ afs_int32 code;
struct afs_conn *tc;
struct vcache *tvc;
struct FsCmdInputs *Inputs;
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 */
#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 */
/* 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 */
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);
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);
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,
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);
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,
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
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,
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 */
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)
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,
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);
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);
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 */
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);
#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);
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);
#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);
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);
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);
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 */
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,
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);
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
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);
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)
#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,
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,
&nbs
git://git.openafs.org / openafs.git / commitdiff