/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
DECL_PIOCTL(PResidencyCmd);
/* Prototypes for private routines */
-static int HandleClientContext(struct afs_ioctl *ablob, int *com,
+static int HandleClientContext(struct afs_ioctl *ablob, int *com,
struct AFS_UCRED **acred, struct AFS_UCRED *credp);
int HandleIoctl(register struct vcache *avc, register afs_int32 acom, struct afs_ioctl *adata);
-int afs_HandlePioctl(struct vcache *avc, afs_int32 acom,
+int afs_HandlePioctl(struct vnode *avp, afs_int32 acom,
register struct afs_ioctl *ablob, int afollow, struct AFS_UCRED **acred);
static int Prefetch(char *apath, struct afs_ioctl *adata, int afollow, struct AFS_UCRED *acred);
#ifdef AFS_SPARC64_LINUX24_ENV
if (current->thread.flags & SPARC_FLAG_32BIT)
-#elif AFS_SPARC64_LINUX20_ENV
- if (current->tss.flags & SPARC_FLAG_32BIT)
+#elif defined(AFS_SPARC64_LINUX20_ENV)
+ if (current->tss.flags & SPARC_FLAG_32BIT)
+#elif defined(AFS_AMD64_LINUX20_ENV)
+ if (current->thread.flags & THREAD_IA32)
#else
#error Not done for this linux type
-#endif /* AFS_SPARC64_LINUX20_ENV */
+#endif
{
AFS_COPYIN(cmarg, (caddr_t) &dst32, sizeof dst32, code);
if (!code)
int HandleIoctl(register struct vcache *avc, register afs_int32 acom, struct afs_ioctl *adata)
{
register afs_int32 code;
-
+
code = 0;
AFS_STATCNT(HandleIoctl);
-
+
switch(acom & 0xff) {
case 1:
avc->states |= CSafeStore;
avc->asynchrony = 0;
break;
-
+
/* case 2 used to be abort store, but this is no longer provided,
since it is impossible to implement under normal Unix.
*/
-
+
case 3: {
/* return the name of the cell this file is open on */
register struct cell *tcell;
register afs_int32 i;
-
+
tcell = afs_GetCell(avc->fid.Cell, READ_LOCK);
if (tcell) {
i = strlen(tcell->cellName) + 1; /* bytes to copy out */
else code = ENOTTY;
}
break;
-
+
case 49: /* VIOC_GETINITPARAMS */
if (adata->out_size < sizeof(struct cm_initparams)) {
code = EFAULT;
sizeof(struct cm_initparams), code);
}
break;
-
+
default:
code = EINVAL;
}
return code; /* so far, none implemented */
}
-
-
+
+
#ifdef AFS_AIX_ENV
/* For aix we don't temporarily bypass ioctl(2) but rather do our
* thing directly in the vnode layer call, VNOP_IOCTL; thus afs_ioctl
{
struct afs_ioctl data;
int error = 0;
-
+
AFS_STATCNT(afs_ioctl);
if (((cmd >> 8) & 0xff) == 'V') {
/* This is a VICEIOCTL call */
int locked;
OSI_VN_CONVERT(tvc);
-
+
AFS_STATCNT(afs_ioctl);
if (((cmd >> 8) & 0xff) == 'V') {
/* This is a VICEIOCTL call */
}
#endif /* AFS_SGI_ENV */
-
/* unlike most calls here, this one uses u.u_error to return error conditions,
since this is really an intercepted chapter 2 call, rather than a vnode
interface call.
#if !defined(AFS_SGI_ENV)
#ifdef AFS_AIX32_ENV
#ifdef AFS_AIX51_ENV
+#ifdef __64BIT__
kioctl(fdes, com, arg, ext, arg2, arg3)
+#else /* __64BIT__ */
+kioctl32(fdes, com, arg, ext, arg2, arg3)
+#endif /* __64BIT__ */
caddr_t arg2, arg3;
#else
kioctl(fdes, com, arg, ext)
int arg;
};
-afs_xioctl (uap, rvp)
+afs_xioctl (uap, rvp)
struct afs_ioctl_sys *uap;
rval_t *rvp;
{
};
int
-afs_xioctl(p, uap, retval)
- struct proc *p;
+afs_xioctl(p, uap, retval)
+ struct proc *p;
register struct ioctl_args *uap;
register_t *retval;
{
{
struct afs_ioctl_sys ua, *uap = &ua;
#else
-int afs_xioctl (void)
+int afs_xioctl (void)
{
register struct a {
int fd;
#endif
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
-
+
AFS_STATCNT(afs_xioctl);
#if defined(AFS_XBSD_ENV)
fdp=p->p_fd;
/* good, this is a vnode; next see if it is an AFS vnode */
#if defined(AFS_AIX32_ENV) || defined(AFS_SUN5_ENV)
tvc = VTOAFS(fd->f_vnode); /* valid, given a vnode */
+#elif defined(AFS_OBSD_ENV)
+ tvc = IsAfsVnode((struct vnode *) fd->f_data) ?
+ VTOAFS((struct vnode *) fd->f_data) : NULL;
#else
tvc = VTOAFS((struct vnode*)fd->f_data); /* valid, given a vnode */
#endif
AFS_GUNLOCK();
#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
return code;
-#else
+#else
#if defined(AFS_SUN5_ENV)
#ifdef AFS_SUN54_ENV
releasef(uap->fd);
#endif
}
#if defined(AFS_LINUX22_ENV)
- else
+ else
code = EINVAL;
#endif
}
#ifdef AFS_AIX41_ENV
ufdrele(uap->fd);
#ifdef AFS_AIX51_ENV
+#ifdef __64BIT__
code = okioctl(fdes, com, arg, ext, arg2, arg3);
-#else
+#else /* __64BIT__ */
+ code = okioctl32(fdes, com, arg, ext, arg2, arg3);
+#endif /* __64BIT__ */
+#else /* !AFS_AIX51_ENV */
code = okioctl(fdes, com, arg, ext);
-#endif
+#endif /* AFS_AIX51_ENV */
return code;
-#else
+#else /* !AFS_AIX41_ENV */
#ifdef AFS_AIX32_ENV
okioctl(fdes, com, arg, ext);
#elif defined(AFS_SUN5_ENV)
return ioctl(p, uap);
#elif defined(AFS_OBSD_ENV)
code = sys_ioctl(p, uap, retval);
-#elif defined(AFS_DARWIN_ENV)
+#elif defined(AFS_DARWIN_ENV)
return ioctl(p, uap, retval);
#elif defined(AFS_OSF_ENV)
code = ioctl(p, args, retval);
}
#endif /* AFS_SGI_ENV */
#endif /* AFS_HPUX102_ENV */
-
+
#if defined(AFS_SGI_ENV)
/* "pioctl" system call entry point; just pass argument to the parameterized
call below */
return u.u_error;
#endif
}
-#endif /* AFS_SGI_ENV */
-#ifdef AFS_OSF_ENV
+#elif defined(AFS_OSF_ENV)
afs_pioctl(p, args, retval)
struct proc *p;
void *args;
return (afs_syscall_pioctl(uap->path, uap->cmd, uap->cmarg, uap->follow));
}
-#else /* AFS_OSF_ENV */
-#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#elif defined(AFS_FBSD50_ENV)
+int
+afs_pioctl(td, args, retval)
+ struct thread *td;
+ void *args;
+ int *retval;
+{
+ struct a {
+ char *path;
+ int cmd;
+ caddr_t cmarg;
+ int follow;
+ } *uap = (struct a *) args;
+
+ AFS_STATCNT(afs_pioctl);
+ return (afs_syscall_pioctl(uap->path, uap->cmd, uap->cmarg, uap->follow, td->td_ucred));
+}
+
+#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
int
afs_pioctl(p, args, retval)
struct proc *p;
char *path;
int cmd;
caddr_t cmarg;
- int follow;
+ int follow;
} *uap = (struct a *) args;
-
+
AFS_STATCNT(afs_pioctl);
return (afs_syscall_pioctl(uap->path, uap->cmd, uap->cmarg, uap->follow, p->p_cred->pc_ucred));
-}
+}
-#else /* AFS_OSF_ENV */
-#endif
#endif
/* macro to avoid adding any more #ifdef's to pioctl code. */
return (code);
#endif
}
- }
+ }
#if !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
if (foreigncreds) {
/*
vp = (struct vnode *) afs_gntovn(vp); /* get vcache from gp */
}
else gp = NULL;
-#endif
+#endif
#ifdef AFS_SUN5_ENV
code = afs_HandlePioctl(vp, com, &data, follow, &credp);
#else
#ifdef AFS_AIX41_ENV
- {
- struct ucred *cred1, *cred2;
-
- if (foreigncreds) {
- cred1 = cred2 = foreigncreds;
- } else {
- cred1 = cred2 = credp;
- }
- code = afs_HandlePioctl(vp, com, &data, follow, &cred1);
- if (cred1 != cred2) {
- /* something changed the creds */
- crset(cred1);
+ {
+ struct ucred *cred1, *cred2;
+
+ if (foreigncreds) {
+ cred1 = cred2 = foreigncreds;
+ } else {
+ cred1 = cred2 = credp;
+ }
+ code = afs_HandlePioctl(vp, com, &data, follow, &cred1);
+ if (cred1 != cred2) {
+ /* something changed the creds */
+ crset(cred1);
+ }
}
- }
#else
#if defined(AFS_HPUX101_ENV)
- {
- struct ucred *cred = p_cred(u.u_procp);
- code = afs_HandlePioctl(vp, com, &data, follow, &cred);
- }
+ {
+ struct ucred *cred = p_cred(u.u_procp);
+ code = afs_HandlePioctl(vp, com, &data, follow, &cred);
+ }
#else
#ifdef AFS_SGI_ENV
- {
- struct cred *credp;
- credp = OSI_GET_CURRENT_CRED();
- code = afs_HandlePioctl(vp, com, &data, follow, &credp);
- }
+ {
+ struct cred *credp;
+ credp = OSI_GET_CURRENT_CRED();
+ code = afs_HandlePioctl(vp, com, &data, follow, &credp);
+ }
#else
#if defined(AFS_LINUX22_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
code = afs_HandlePioctl(vp, com, &data, follow, &credp);
}
PIOCTL_FREE_CRED();
#if defined(KERNEL_HAVE_UERROR)
- if (!getuerror())
+ if (!getuerror())
setuerror(code);
return (getuerror());
#else
return (code);
#endif
}
-
-
-int afs_HandlePioctl(struct vcache *avc, afs_int32 acom,
+
+
+int afs_HandlePioctl(struct vnode *avp, afs_int32 acom,
register struct afs_ioctl *ablob, int afollow, struct AFS_UCRED **acred)
{
+ struct vcache *avc;
struct vrequest treq;
register afs_int32 code;
register afs_int32 function, device;
int pioctlSwSize;
struct afs_fakestat_state fakestate;
+ avc = avp ? VTOAFS(avp) : NULL;
afs_Trace3(afs_iclSetp, CM_TRACE_PIOCTL, ICL_TYPE_INT32, acom & 0xff,
ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, afollow);
AFS_STATCNT(HandlePioctl);
}
device = (acom & 0xff00) >> 8;
switch (device) {
- case 'V': /* Original pioctl's */
- pioctlSw = VpioctlSw;
- pioctlSwSize = sizeof(VpioctlSw);
- break;
- case 'C': /* Coordinated/common pioctl's */
- pioctlSw = CpioctlSw;
- pioctlSwSize = sizeof(CpioctlSw);
- break;
- default:
- afs_PutFakeStat(&fakestate);
- return EINVAL;
+ case 'V': /* Original pioctls */
+ pioctlSw = VpioctlSw;
+ pioctlSwSize = sizeof(VpioctlSw);
+ break;
+ case 'C': /* Coordinated/common pioctls */
+ pioctlSw = CpioctlSw;
+ pioctlSwSize = sizeof(CpioctlSw);
+ break;
+ default:
+ afs_PutFakeStat(&fakestate);
+ return EINVAL;
}
function = acom & 0xff;
if (function >= (pioctlSwSize / sizeof(char *))) {
afs_PutFakeStat(&fakestate);
- return EINVAL; /* out of range */
+ return EINVAL; /* out of range */
}
inSize = ablob->in_size;
- if (inSize >= PIGGYSIZE) return E2BIG;
+
+ /* Do all range checking before continuing */
+ if (inSize >= PIGGYSIZE || inSize < 0 || ablob->out_size < 0)
+ return E2BIG;
+
inData = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
if (inSize > 0) {
- AFS_COPYIN(ablob->in, inData, inSize, code);
- inData[inSize]='\0';
+ AFS_COPYIN(ablob->in, inData, inSize, code);
+ inData[inSize]='\0';
}
else code = 0;
if (code) {
code = (*pioctlSw[function])(avc, function, &treq, inData, outData, inSize, &outSize, acred);
osi_FreeLargeSpace(inData);
if (code == 0 && ablob->out_size > 0) {
- if (outSize > ablob->out_size) outSize = ablob->out_size;
- if (outSize >= PIGGYSIZE) code = E2BIG;
- else if (outSize) {
- outData[outSize]='\0';
- AFS_COPYOUT(outData, ablob->out, outSize, code);
- }
+ if (outSize > ablob->out_size) outSize = ablob->out_size;
+ if (outSize >= PIGGYSIZE) code = E2BIG;
+ else if (outSize) {
+ outData[outSize]='\0';
+ AFS_COPYOUT(outData, ablob->out, outSize, code);
+ }
}
osi_FreeLargeSpace(outData);
afs_PutFakeStat(&fakestate);
return afs_CheckCode(code, &treq, 41);
- }
-
+}
+
DECL_PIOCTL(PGetFID)
{
AFS_STATCNT(PGetFID);
*aoutSize = sizeof(struct VenusFid);
return 0;
}
-
+
DECL_PIOCTL(PSetAcl)
{
register afs_int32 code;
struct AFSVolSync tsync;
struct AFSFetchStatus OutStatus;
XSTATS_DECLS;
-
+
AFS_STATCNT(PSetAcl);
if (!avc)
return EINVAL;
}
if (avc && (sbr->sb_thisfile != -1)) {
- if (afs_AccessOK(avc, PRSFS_WRITE | PRSFS_ADMINISTER,
+ if (afs_AccessOK(avc, PRSFS_WRITE | PRSFS_ADMINISTER,
areq, DONT_CHECK_MODE_BITS))
avc->asynchrony = sbr->sb_thisfile;
else code = EACCES;
afs_gcpags = AFS_GCPAGS_USERDISABLED;
return 0;
}
-
+
DECL_PIOCTL(PGetAcl)
{
struct AFSOpaque acl;
}
return code;
}
-
+
DECL_PIOCTL(PNoop)
{
AFS_STATCNT(PNoop);
return 0;
}
-
+
DECL_PIOCTL(PBogus)
{
AFS_STATCNT(PBogus);
return EINVAL;
}
-
+
DECL_PIOCTL(PGetFileCell)
{
register struct cell *tcell;
-
+
AFS_STATCNT(PGetFileCell);
if (!avc) return EINVAL;
tcell = afs_GetCell(avc->fid.Cell, READ_LOCK);
*aoutSize = strlen(aout) + 1;
return 0;
}
-
+
DECL_PIOCTL(PGetWSCell)
{
struct cell *tcell = NULL;
-
+
AFS_STATCNT(PGetWSCell);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
tcell = afs_GetPrimaryCell(READ_LOCK);
afs_PutCell(tcell, READ_LOCK);
return 0;
}
-
+
DECL_PIOCTL(PGetUserCell)
{
register afs_int32 i;
register struct unixuser *tu;
register struct cell *tcell;
-
+
AFS_STATCNT(PGetUserCell);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
/* return the cell name of the primary cell for this user */
}
return 0;
}
-
+
DECL_PIOCTL(PSetTokens)
{
afs_int32 i;
int stLen;
struct vrequest treq;
afs_int32 flag, set_parent_pag = 0;
-
+
AFS_STATCNT(PSetTokens);
if (!afs_resourceinit_flag) {
return EIO;
uprintf("Process %d (%s) tried to change pags in PSetTokens\n",
p->p_pid, p->p_comm);
if (!setpag(p, acred, -1, &pag, 1)) {
-#else
+#else
#ifdef AFS_OSF_ENV
if (!setpag(u.u_procp, acred, -1, &pag, 1)) { /* XXX u.u_procp is a no-op XXX */
#else
else
return ESRCH;
}
-}
+}
DECL_PIOCTL(PGetVolumeStatus)
{
AFS_STATCNT(PSetVolumeStatus);
if (!avc) return EINVAL;
- tvp = afs_GetVolume(&avc->fid, areq, READ_LOCK);
+ tvp = afs_GetVolume(&avc->fid, areq, READ_LOCK);
if (tvp) {
if (tvp->states & (VRO | VBackup)) {
afs_PutVolume(tvp, READ_LOCK);
strcpy(aout, tvc->linkData);
*aoutSize = strlen(tvc->linkData)+1;
}
- } else
+ } else
code = EIO;
}
ReleaseWriteLock(&tvc->lock);
int newStyle;
AFS_STATCNT(PGetTokens);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
/* weird interface. If input parameter is present, it is an integer and
}
if (tu) {
/*
- * No need to hold a read lock on each user entry
+ * No need to hold a read lock on each user entry
*/
tu->refCount++;
}
register struct unixuser *tu;
AFS_STATCNT(PUnlog);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
i = UHash(areq->uid);
{
afs_int32 newHostAddr;
afs_int32 oldHostAddr;
-
+
AFS_STATCNT(PMariner);
if (afs_mariner)
memcpy((char *)&oldHostAddr, (char *)&afs_marinerHost, sizeof(afs_int32));
else
oldHostAddr = 0xffffffff; /* disabled */
-
+
memcpy((char *)&newHostAddr, ain, sizeof(afs_int32));
if (newHostAddr == 0xffffffff) {
/* disable mariner operations */
AFS_STATCNT(PCheckServers);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
if (*lp == 0x12345678) { /* For afs3.3 version */
pcheck=(struct chservinfo *)ain;
if (pcheck->tinterval >= 0) {
- cp = aout;
+ cp = aout;
memcpy(cp, (char *)&PROBE_INTERVAL, sizeof(afs_int32));
*aoutSize = sizeof(afs_int32);
if (pcheck->tinterval > 0) {
} else { /* For pre afs3.3 versions */
memcpy((char *)&temp, ain, sizeof(afs_int32));
cp = ain+sizeof(afs_int32);
- if (ainSize > sizeof(afs_int32))
+ if (ainSize > sizeof(afs_int32))
havecell = 1;
}
- /*
+ /*
* 1: fast check, don't contact servers.
* 2: local cell only.
*/
DECL_PIOCTL(PCheckVolNames)
{
AFS_STATCNT(PCheckVolNames);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
afs_CheckRootVolume();
afs_int32 retValue;
AFS_STATCNT(PCheckAuth);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
retValue = 0;
if (!tu) retValue = EACCES;
else {
/* we have a user */
- ObtainReadLock(&afs_xsrvAddr);
+ ObtainReadLock(&afs_xsrvAddr);
ObtainReadLock(&afs_xconn);
/* any tokens set? */
register struct server *ts;
register afs_int32 i;
register char *cp;
-
+
AFS_STATCNT(PFindVolume);
if (!avc) return EINVAL;
tvp = afs_GetVolume(&avc->fid, areq, READ_LOCK);
{
register afs_int32 code;
afs_int32 temp;
-
+
AFS_STATCNT(PViceAccess);
if (!avc) return EINVAL;
code = afs_VerifyVCache(avc, areq);
}
DECL_PIOCTL(PSetCacheSize)
-{
+{
afs_int32 newValue;
int waitcnt = 0;
-
+
AFS_STATCNT(PSetCacheSize);
if (!afs_osi_suser(*acred))
return EACCES;
register afs_int32 code, linkedstate=0, ls;
u_short fsport = 0, vlport = 0;
afs_int32 scount;
-
+
AFS_STATCNT(PNewCell);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
if (!afs_osi_suser(*acred))
char *tp = ain;
register afs_int32 code;
char *realName, *aliasName;
-
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
if (!afs_osi_suser(*acred))
register char *cp, *tp = ain;
AFS_STATCNT(PListCells);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
memcpy((char *)&whichCell, tp, sizeof(afs_int32));
register struct cell_alias *tcalias=0;
register char *cp, *tp = ain;
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
if (ainSize < sizeof(afs_int32))
return EINVAL;
tp += sizeof(afs_int32);
tcalias = afs_GetCellAlias(whichAlias);
- if (tcalias) {
+ if (tcalias) {
cp = aout;
strcpy(cp, tcalias->alias);
cp += strlen(tcalias->alias)+1;
if (tvc->linkData) {
if ((tvc->linkData[0] != '#') && (tvc->linkData[0] != '%'))
code = EINVAL;
- } else
+ } else
code = EIO;
}
ReleaseWriteLock(&tvc->lock);
code = 0;
out:
if (sysState.allocked) osi_FreeLargeSpace(bufp);
- return code;
+ return code;
}
DECL_PIOCTL(PVenusLogging)
afs_int32 temp;
AFS_STATCNT(PGetCellStatus);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
tcell = afs_GetCellByName(ain, READ_LOCK);
{
register struct cell *tcell;
afs_int32 temp;
-
+
if (!afs_osi_suser(*acred))
return EACCES;
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
tcell = afs_GetCellByName(ain+2*sizeof(afs_int32), WRITE_LOCK);
AFS_STATCNT(PFlushVolumeData);
if (!avc)
return EINVAL;
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
volume = avc->fid.Fid.Volume; /* who to zap */
cell = avc->fid.Cell;
- /*
+ /*
* Clear stat'd flag from all vnodes from this volume; this will invalidate all
* the vcaches associated with the volume.
*/
}
ReleaseReadLock(&afs_xvolume);
- /* probably, a user is doing this, probably, because things are screwed up.
+ /* probably, a user is doing this, probably, because things are screwed up.
* maybe it's the dnlc's fault? */
- osi_dnlc_purge();
+ osi_dnlc_purge();
return 0;
}
register afs_int32 code;
struct vcxstat stat;
afs_int32 mode, i;
-
+
/* AFS_STATCNT(PGetVnodeXStatus); */
if (!avc) return EINVAL;
code = afs_VerifyVCache(avc, areq);
else
mode = PRSFS_READ;
if (!afs_AccessOK(avc, mode, areq, CHECK_MODE_BITS))
- return EACCES;
+ return EACCES;
stat.fid = avc->fid;
hset32(stat.DataVersion, hgetlo(avc->m.DataVersion));
stat.lock = avc->lock;
} else { /* Local guy; only root can change sysname */
if (!afs_osi_suser(*acred))
return EACCES;
-
+
/* clear @sys entries from the dnlc, once afs_lookup can
do lookups of @sys entries and thinks it can trust them */
/* privs ok, store the entry, ... */
afs_int32 *p = (afs_int32 *) arg;
afs_int32 *l = p + 1;
int i, s = p[0];
-
+
for (i=0; i<s; i++) {
if (l[i] == cell->cellNum) {
ObtainWriteLock(&cell->lock, 690);
return NULL;
}
-static void ReSortCells(int s, afs_int32 *l, int vlonly)
+static void ReSortCells(int s, afs_int32 *l, int vlonly)
{
int i;
struct volume *j;
ObtainWriteLock(&j->lock,233);
afs_SortServers(j->serverHost, MAXHOSTS);
ReleaseWriteLock(&j->lock);
- break;
+ break;
}
}
}
struct server *srvr = NULL;
afs_int32 touched[34];
int isfs;
-
+
touchedSize=0;
- for (k=0; k < num; sp++, k++) {
+ for (k=0; k < num; sp++, k++) {
if (debugsetsp) {
printf ("sp host=%x, rank=%d\n",sp->host.s_addr, sp->rank);
}
matches=0;
ObtainReadLock(&afs_xserver);
-
+
i = SHash(sp->host.s_addr);
for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
if (sa->sa_ip == sp->host.s_addr) {
srvr = sa->server;
- isfs = (srvr->cell && (sa->sa_portal == srvr->cell->fsport))
- || (sa->sa_portal == AFS_FSPORT);
+ isfs = (srvr->cell && (sa->sa_portal == srvr->cell->fsport))
+ || (sa->sa_portal == AFS_FSPORT);
if ((!vlonly && isfs) || (vlonly && !isfs)) {
matches++;
break;
}
}
}
-
+
if (sa && matches) { /* found one! */
if (debugsetsp) {
printf ("sa ip=%x, ip_rank=%d\n",sa->sa_ip, sa->sa_iprank);
}
sa->sa_iprank = sp->rank + afs_randomMod15();
afs_SortOneServer(sa->server);
-
+
if (srvr->cell) {
/* if we don't know yet what cell it's in, this is moot */
for (j=touchedSize-1; j>=0 && touched[j] != srvr->cell->cellNum; j--)
}
}
}
-
+
ReleaseReadLock(&afs_xserver);
/* if we didn't find one, start to create one. */
/* Note that it doesn't have a cell yet... */
if (!matches) {
afs_uint32 temp = sp->host.s_addr;
- srvr = afs_GetServer(&temp, 1, 0, (vlonly ? AFS_VLPORT : AFS_FSPORT),
+ srvr = afs_GetServer(&temp, 1, 0, (vlonly ? AFS_VLPORT : AFS_FSPORT),
WRITE_LOCK, (afsUUID *)0,0);
srvr->addr->sa_iprank = sp->rank + afs_randomMod15();
afs_PutServer(srvr, WRITE_LOCK);
}
} /* for all cited preferences */
-
+
ReSortCells(touchedSize, touched, vlonly);
return 0;
}
struct setspref *ssp;
AFS_STATCNT(PSetSPrefs);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
if (!afs_osi_suser(*acred))
return EACCES;
- if (ainSize < sizeof(struct setspref))
+ if (ainSize < sizeof(struct setspref))
return EINVAL;
ssp = (struct setspref *)ain;
- if (ainSize < sizeof(struct spref)*ssp->num_servers)
+ if (ainSize < sizeof(struct spref)*ssp->num_servers)
return EINVAL;
- afs_setsprefs(&(ssp->servers[0]), ssp->num_servers,
+ afs_setsprefs(&(ssp->servers[0]), ssp->num_servers,
(ssp->flags & DBservers));
return 0;
}
{
struct spref *sp;
AFS_STATCNT(PSetSPrefs);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
/* some notes on the following code...
* in the hash table of server structs, all servers with the same IP address
- * will be on the same overflow chain.
- * This could be sped slightly in some circumstances by having it cache the
+ * will be on the same overflow chain.
+ * This could be sped slightly in some circumstances by having it cache the
* immediately previous slot in the hash table and some supporting information
* Only reports file servers now.
*/
struct srvAddr *sa;
int vlonly; /* just return vlservers ? */
int isfs;
-
+
AFS_STATCNT(PGetSPrefs);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
-
+
if (ainSize < sizeof (struct sprefrequest_33)) {
return ENOENT;
}
else {
spin = ((struct sprefrequest *) ain);
}
-
+
if (ainSize > sizeof (struct sprefrequest_33)) {
vlonly = (spin->flags & DBservers);
}
else vlonly = 0;
-
+
/* struct sprefinfo includes 1 server struct... that size gets added
* in during the loop that follows.
*/
spout->next_offset = spin->offset;
spout->num_servers = 0;
srvout = spout->servers;
-
+
ObtainReadLock(&afs_xserver);
for (i=0, j=0; j < NSERVERS; j++) { /* sift through hash table */
for (sa = afs_srvAddrs[j]; sa; sa = sa->next_bkt, i++) {
continue; /* catch up to where we left off */
}
spout->next_offset++;
-
+
srvr = sa->server;
- isfs = (srvr->cell && (sa->sa_portal == srvr->cell->fsport))
- || (sa->sa_portal == AFS_FSPORT);
-
+ isfs = (srvr->cell && (sa->sa_portal == srvr->cell->fsport))
+ || (sa->sa_portal == AFS_FSPORT);
+
if ((vlonly && isfs) || (!vlonly && !isfs)) {
/* only report ranks for vl servers */
continue;
}
-
+
srvout->host.s_addr = sa->sa_ip;
srvout->rank = sa->sa_iprank;
*aoutSize += sizeof(struct spref);
}
}
ReleaseReadLock(&afs_xserver);
-
+
spout->next_offset = 0; /* start over from the beginning next time */
return 0;
}
}
if (rxp->rx_MyMaxSendSize)
rx_MyMaxSendSize = rxp->rx_MyMaxSendSize;
-
+
return 0;
}
osi_Assert(ISAFS_GLOCK());
#endif
AFS_STATCNT(HandleClientContext);
- if (ablob->in_size < PIOCTL_HEADER*sizeof(afs_int32)) {
+ if (ablob->in_size < PIOCTL_HEADER*sizeof(afs_int32)) {
/* Must at least include the PIOCTL_HEADER header words required by the protocol */
return EINVAL; /* Too small to be good */
}
*/
i = (*com) & 0xff;
if (!afs_osi_suser(credp)) {
-#ifdef AFS_SGI_ENV
+#ifdef AFS_SGI_ENV
#ifndef AFS_SGI64_ENV
/* Since SGI's suser() returns explicit failure after the call.. */
- u.u_error = 0;
-#endif
+ u.u_error = 0;
+#endif
#endif
/* check for acceptable opcodes for normal folks, which are, so far,
* set tokens and unlog.
}
newcred = crget();
#ifdef AFS_AIX41_ENV
- setuerror(0);
+ setuerror(0);
#endif
newcred->cr_gid = RMTUSER_REQ;
#ifdef AFS_AIX51_ENV
int i,j;
AFS_STATCNT(PGetCPrefs);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
if ( ainSize < sizeof (struct sprefrequest ))
return EINVAL;
-
+
spin = (struct sprefrequest *) ain;
spout = (struct sprefinfo *) aout;
for ( i=spin->offset, j=0; (i < afs_cb_interface.numberOfInterfaces)
&& ( j< maxNumber) ; i++, j++, srvout++)
srvout->host.s_addr = afs_cb_interface.addr_in[i];
-
+
spout->num_servers = j;
*aoutSize = sizeof(struct sprefinfo) +(j-1)* sizeof (struct spref);
spout->next_offset = 0; /* start from beginning again */
else
spout->next_offset = spin->offset + j;
-
+
ReleaseReadLock(&afs_xinterface);
return 0;
}
int i;
AFS_STATCNT(PSetCPrefs);
- if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
+ if ( !afs_resourceinit_flag ) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
sin = (struct setspref *)ain;
} else
code = -1;
} while
- (afs_Analyze(tc, code, &tvc->fid, areq,
- AFS_STATS_FS_RPCIDX_RESIDENCYRPCS, SHARED_LOCK,
+ (afs_Analyze(tc, code, &tvc->fid, areq,
+ AFS_STATS_FS_RPCIDX_RESIDENCYRPCS, SHARED_LOCK,
NULL));
/* This call is done only to have the callback things handled correctly */
afs_FetchStatus(tvc, &tfid, areq, &OutStatus);
} else
code = -1;
} while
- (afs_Analyze(tc, code, &tvc->fid, areq,
+ (afs_Analyze(tc, code, &tvc->fid, areq,
AFS_STATS_FS_RPCIDX_RESIDENCYRPCS, SHARED_LOCK,
NULL));
/* This call is done to have the callback things handled correctly */
*aoutSize = sizeof(struct ResidencyCmdOutputs);
}
return code;
-}
+}
git://git.openafs.org / openafs.git / blobdiff