tviced: project viced vlserver libafsrpc libafsauthent
case ${SYS_NAME} in \
- alpha_dux*|sgi_*|sun*_*|rs_aix*|*linux*|hp_ux110) \
+ alpha_dux*|sgi_*|sun*_5*|rs_aix*|*linux*|hp_ux110) \
${COMPILE_PART1} tviced ${COMPILE_PART2} ;; \
*) \
echo Not building MT viced for ${SYS_NAME} ;; \
vfsck: vol
set -x; \
case ${SYS_NAME} in \
- sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* | *fbsd* | *_obsd* ) \
+ sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* | *fbsd* | *_obsd* | sun*_4* ) \
echo skip vfsck for ${SYS_NAME} ;; \
* ) \
${COMPILE_PART1} vfsck ${COMPILE_PART2} ;; \
libuafs: libuafs_setup ${UKERNELDIR}
set -x; \
case ${SYS_NAME} in \
- hp_ux102* | *_obsd* ) \
+ hp_ux102* | *_obsd* | sun*_4* ) \
echo Skipping libuafs for ${SYS_NAME} ;; \
* ) \
${COMPILE_PART1} libuafs ${COMPILE_PART2} ;; \
# pthread based user space RX library
libafsrpc: rx rxkad des
case ${SYS_NAME} in \
- alpha_dux*|sgi_*|sun4x_*|rs_aix*|*linux*|hp_ux110) \
+ alpha_dux*|sgi_*|sun4x_*|rs_aix*|*linux*|hp_ux110|*fbsd*) \
${COMPILE_PART1} libafsrpc ${COMPILE_PART2} ;; \
*) \
echo Not building MT libafsrpc for ${SYS_NAME} ;; \
libafsauthent: ubik auth kauth libafsrpc
case ${SYS_NAME} in \
- alpha_dux*|sgi_*|sun4x_*|rs_aix*|*linux*|hp_ux110) \
+ alpha_dux*|sgi_*|sun4x_*|rs_aix*|*linux*|hp_ux110|*fbsd*) \
${COMPILE_PART1} libafsauthent ${COMPILE_PART2} ;; \
*) \
echo Not building MT libafsrpc for ${SYS_NAME} ;; \
esac
+shlibafsrpc: rx rxkad des
+ case ${SYS_NAME} in \
+ alpha_dux*|sgi_*|sun4x_*|sunx86_*|rs_aix*|*linux*|hp_ux110) \
+ ${COMPILE_PART1} shlibafsrpc ${COMPILE_PART2} ;; \
+ *) \
+ echo Not building shared libafsrpc for ${SYS_NAME} ;; \
+ esac
+
+shlibafsauthent: ubik auth kauth shlibafsrpc
+ case ${SYS_NAME} in \
+ alpha_dux*|sgi_*|sun4x_*|sunx86_*|rs_aix*|*linux*|hp_ux110) \
+ ${COMPILE_PART1} shlibafsauthent ${COMPILE_PART2} ;; \
+ *) \
+ echo Not building shared libafsrpc for ${SYS_NAME} ;; \
+ esac
+
libadmin_real:
${COMPILE_PART1} libadmin ${COMPILE_PART2}
${COMPILE_PART1} libadmin/adminutil ${COMPILE_PART2}
finale: project cmd comerr afsd allrcmds butc tbutc @ENABLE_KERNEL_MODULE@ libuafs audit kauth log package \
ptserver scout bu_utils ubik uss bozo vfsck volser \
venus update xstat afsmonitor dauth rxdebug libafsrpc \
- libafsauthent libadmin
+ libafsauthent shlibafsrpc shlibafsauthent libadmin
${COMPILE_PART1} finale ${COMPILE_PART2}
finale_nolibafs: project cmd comerr afsd allrcmds butc tbutc libuafs audit kauth log package \
ptserver scout bu_utils ubik uss bozo vfsck volser \
venus update xstat afsmonitor dauth rxdebug libafsrpc \
- libafsauthent libadmin
+ libafsauthent shlibafsrpc shlibafsauthent libadmin
${COMPILE_PART1} finale ${COMPILE_PART2}
# Use washtool to ensure MakefileProto is current and obj/libafs exists.
-${COMPILE_PART1} rxdebug ${COMPILE_CLEAN}
-${COMPILE_PART1} libafsrpc ${COMPILE_CLEAN}
-${COMPILE_PART1} libafsauthent ${COMPILE_CLEAN}
+ -${COMPILE_PART1} shlibafsrpc ${COMPILE_CLEAN}
+ -${COMPILE_PART1} shlibafsauthent ${COMPILE_CLEAN}
-${COMPILE_PART1} libadmin ${COMPILE_CLEAN}
-${COMPILE_PART1} libadmin/adminutil ${COMPILE_CLEAN}
-${COMPILE_PART1} libadmin/client ${COMPILE_CLEAN}
src/rxstat/Makefile \
src/scout/Makefile \
src/sgistuff/Makefile \
+ src/shlibafsauthent/Makefile \
+ src/shlibafsrpc/Makefile \
src/sia/Makefile \
src/sys/Makefile \
src/tbutc/Makefile \
-OpenAFS News -- history of user-visible changes. August 2, 2002.
+OpenAFS News -- history of user-visible changes. September 25, 2002.
+
+* Changes incorporated in OpenAFS 1.2.7
+
+** MacOS X 10.2 is now supported. FreeBSD 4.3 and later support is included
+ in this release, but is still under active development and should only
+ be used by those doing active development on the OpenAFS FreeBSD client.
+
+** When fakestat is enabled on MacOSX, the Finder can be used to browse
+ a fully-populated /afs directory. However, this precludes reliable
+ use of entire volumes as MacOS bundles (i.e. containing a Contents
+ directory in the root of the volume).
+
+** The fileserver will now use Rx pings to determine if clients are reachable
+ prior to allocating resources to them, to prevent asymmetric clients from
+ consuming all fileserver resources.
* Changes incorporated in OpenAFS 1.2.6
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/LINUX/osi_misc.c,v 1.11 2002/08/02 04:57:38 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/LINUX/osi_misc.c,v 1.12 2002/09/26 19:18:06 hartmans Exp $");
#include "../afs/sysincludes.h"
#include "../afs/afsincludes.h"
cacheInode = dp->d_inode->i_ino;
cacheDev.dev = dp->d_inode->i_dev;
- afs_fsfragsize = dp->d_inode->i_sb->s_blocksize;
+ afs_fsfragsize = dp->d_inode->i_sb->s_blocksize - 1;
afs_cacheSBp = dp->d_inode->i_sb;
dput(dp);
KERNEL_SPACE_DECL;
struct file *filp = &file->file;
off_t offset = file->offset;
+ unsigned long savelim;
/* Seek to the desired position. Return -1 on error. */
if (filp->f_op->llseek) {
else
filp->f_pos = offset;
+ savelim = current->rlim[RLIMIT_FSIZE].rlim_cur;
+ current->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
+
/* Read/Write the data. */
TO_USER_SPACE();
if (rw == UIO_READ)
code = asize;
TO_KERNEL_SPACE();
+ current->rlim[RLIMIT_FSIZE].rlim_cur = savelim;
+
if (code >=0) {
*resid = asize - code;
return 0;
int code = 0;
struct iovec *iov;
int count;
+ unsigned long savelim;
+
+ savelim = current->rlim[RLIMIT_FSIZE].rlim_cur;
+ current->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
if (uiop->uio_seg == AFS_UIOSYS)
TO_USER_SPACE();
uiop->uio_iovcnt--;
continue;
}
-
+
if (rw == UIO_READ)
code = FOP_READ(filp, iov->iov_base, count);
else
if (uiop->uio_seg == AFS_UIOSYS)
TO_KERNEL_SPACE();
+ current->rlim[RLIMIT_FSIZE].rlim_cur = savelim;
+
return code;
}
case ${SYS_NAME} in \
sgi_* ) \
gencat -m afszcm.cat afs_trace.msf ;; \
+ sun*_4* ) \
+ /usr/etc/gencat afszcm.cat afs_trace.msf ;; \
*_linux* ) \
gencat --new afszcm.cat afs_trace.msf ;; \
ppc_darwin* | i386_fbsd*) \
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_lookup.c,v 1.11 2002/08/02 04:57:38 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_lookup.c,v 1.12 2002/09/26 19:18:06 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
struct VenusFid tfid;
struct cell *tcell;
char *cpos, *volnamep;
- char type, buf[128];
+ char type, *buf;
afs_int32 prefetchRO; /* 1=>No 2=>Yes */
afs_int32 mtptCell, assocCell, hac=0;
afs_int32 samecell, roname, len;
* Don't know why we do this. Would have still found it in above call - jpm.
*/
if (!tvp && (prefetchRO == 2)) {
- strcpy(buf, volnamep);
- afs_strcat(buf, ".readonly");
+ buf = (char *)osi_AllocSmallSpace(strlen(volnamep)+10);
- tvp = afs_GetVolumeByName(buf, mtptCell, 1, areq, WRITE_LOCK);
+ strcpy(buf, volnamep);
+ afs_strcat(buf, ".readonly");
- /* Try the associated linked cell if failed */
- if (!tvp && hac && areq->volumeError) {
- tvp = afs_GetVolumeByName(buf, assocCell, 1, areq, WRITE_LOCK);
- }
+ tvp = afs_GetVolumeByName(buf, mtptCell, 1, areq, WRITE_LOCK);
+
+ /* Try the associated linked cell if failed */
+ if (!tvp && hac && areq->volumeError) {
+ tvp = afs_GetVolumeByName(buf, assocCell, 1, areq, WRITE_LOCK);
+ }
+ osi_FreeSmallSpace(buf);
}
if (!tvp) return ENODEV; /* Couldn't find the volume */
/* Don't cross mountpoint from a BK to a BK volume */
if ((avc->states & CBackup) && (tvp->states & VBackup)) {
afs_PutVolume(tvp, WRITE_LOCK);
- return ELOOP;
+ return ENODEV;
}
/* If we want (prefetched) the RO and it exists, then drop the
struct sysname_info sysState; /* used only for @sys checking */
int dynrootRetry = 1;
struct afs_fakestat_state fakestate;
+ int tryEvalOnly = 0;
AFS_STATCNT(afs_lookup);
afs_InitFakeStat(&fakestate);
if (code = afs_InitReq(&treq, acred))
goto done;
- code = afs_EvalFakeStat(&adp, &fakestate, &treq);
- if (code)
- goto done;
#ifdef AFS_OSF_ENV
ndp->ni_dvp = AFSTOV(adp);
memcpy(aname, ndp->ni_ptr, ndp->ni_namelen);
aname[ndp->ni_namelen] = '\0';
#endif /* AFS_OSF_ENV */
+#if defined(AFS_DARWIN_ENV)
+ /* Workaround for MacOSX Finder, which tries to look for
+ * .DS_Store and Contents under every directory.
+ */
+ if (afs_fakestat_enable && adp->mvstat == 1) {
+ if (strcmp(aname, ".DS_Store") == 0)
+ tryEvalOnly = 1;
+ if (strcmp(aname, "Contents") == 0)
+ tryEvalOnly = 1;
+ }
+#endif
+
+ if (tryEvalOnly)
+ code = afs_TryEvalFakeStat(&adp, &fakestate, &treq);
+ else
+ code = afs_EvalFakeStat(&adp, &fakestate, &treq);
+ if (tryEvalOnly && adp->mvstat == 1)
+ code = ENOENT;
+ if (code)
+ goto done;
+
*avcp = (struct vcache *) 0; /* Since some callers don't initialize it */
/* come back to here if we encounter a non-existent object in a read-only
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_readdir.c,v 1.8 2002/08/02 04:57:38 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_readdir.c,v 1.9 2002/09/26 19:18:06 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
#else
struct min_direct { /* miniature direct structure */
/* If struct direct changes, this must too */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
afs_uint32 d_fileno;
u_short d_reclen;
u_char d_type;
#endif /* AFS_SUN56_ENV */
#endif /* AFS_HPUX100_ENV */
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+int afs_readdir_type(avc, ade)
+struct DirEntry * ade;
+struct vcache * avc;
+{
+ struct VenusFid tfid;
+ struct vcache *tvc;
+ int vtype;
+ tfid.Cell=avc->fid.Cell;
+ tfid.Fid.Volume=avc->fid.Fid.Volume;
+ tfid.Fid.Vnode=ntohl(ade->fid.vnode);
+ tfid.Fid.Unique=ntohl(ade->fid.vunique);
+ if ((avc->states & CForeign) == 0 &&
+ (ntohl(ade->fid.vnode) & 1)) {
+ return DT_DIR;
+ } else if ((tvc=afs_FindVCache(&tfid,0,0,0,0))) {
+ if (tvc->mvstat) {
+ afs_PutVCache(tvc, WRITE_LOCK);
+ return DT_DIR;
+ } else if (((tvc->states) & (CStatd|CTruth))) {
+ /* CTruth will be set if the object has
+ *ever* been statd */
+ vtype=vType(tvc);
+ afs_PutVCache(tvc, WRITE_LOCK);
+ if (vtype == VDIR)
+ return DT_DIR;
+ else if (vtype == VREG)
+ return DT_REG;
+ /* Don't do this until we're sure it can't be a mtpt */
+ /* else if (vtype == VLNK)
+ type=DT_LNK; */
+ /* what other types does AFS support? */
+ } else
+ afs_PutVCache(tvc, WRITE_LOCK);
+ }
+ return DT_UNKNOWN;
+}
+#endif
+
#ifdef AFS_AIX41_ENV
#define AFS_MOVE_LOCK() AFS_GLOCK()
#define AFS_MOVE_UNLOCK() AFS_GUNLOCK()
#define AFS_MOVE_LOCK()
#define AFS_MOVE_UNLOCK()
#endif
-
char bufofzeros[64]; /* gotta fill with something */
afs_readdir_move (de, vc, auio, slen, rlen, off)
struct DirEntry * de;
#if defined(AFS_SUN_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV)
sdirEntry.d_off = off;
#endif
-#if defined(AFS_DARWIN_ENV)
- sdirEntry.d_type=DT_UNKNOWN;
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+ sdirEntry.d_type=afs_readdir_type(vc, de);
#endif
#if defined(AFS_SGI_ENV)
* It has to do with 'offset' (seek locations).
*/
-#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
afs_readdir(OSI_VC_ARG(avc), auio, acred, eofp)
int *eofp;
#else
#endif /* AFS_SGI61_ENV */
#endif /* defined(AFS_SGI53_ENV) */
-#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
/* Not really used by the callee so we ignore it for now */
if (eofp) *eofp = 0;
#endif
} else {
/* nothin to hand over */
}
-#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV)
+#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
if (eofp) *eofp = 1; /* Set it properly */
#endif
if (ode) DRelease(ode, 0);
#ifdef AFS_OSF_ENV
#define CWired 0x00000800 /* OSF hack only */
#else
+#ifdef AFS_DARWIN_ENV
+#define CUBCinit 0x00000800
+#else
#define CWRITE_IGN 0x00000800 /* Next OS hack only */
#endif
+#endif
#define CUnique 0x00001000 /* vc's uniquifier - latest unifiquier for fid */
#define CForeign 0x00002000 /* this is a non-afs vcache */
#define CHasPages 0x00004000
* Do not try to get the vcache lock when the vlock is held */
afs_rwlock_t vlock;
#endif /* defined(AFS_SUN5_ENV) */
-#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_DARWIN_ENV)
#if defined(AFS_SUN5_ENV)
krwlock_t rwlock;
struct cred *credp;
#endif
+#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
afs_bozoLock_t pvnLock; /* see locks.x */
#endif
#ifdef AFS_AIX32_ENV
#endif
#ifdef AFS_DARWIN_ENV
struct lock__bsd__ rwlock;
+#endif
+#ifdef AFS_FBSD_ENV
+ struct lock rwlock;
#endif
afs_int32 parentVnode; /* Parent dir, if a file. */
afs_int32 parentUnique;
#else
#ifdef AFS_DARWIN_ENV
#define afs_VerifyVCache(avc, areq) \
- (((avc)->states & CStatd) ? (osi_VM_Setup(avc), 0) : \
+ (((avc)->states & CStatd) ? (osi_VM_Setup(avc, 0), 0) : \
afs_VerifyVCache2((avc),areq))
#else
#define afs_VerifyVCache(avc, areq) \
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_call.c,v 1.13 2002/08/02 04:57:37 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_call.c,v 1.14 2002/09/26 19:18:06 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
#ifdef AFS_SGI62_ENV
#include "../h/hashing.h"
#endif
-#if !defined(AFS_HPUX110_ENV)
+#if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN60_ENV)
#include "netinet/in_var.h"
#endif
#endif /* !defined(UKERNEL) */
#elif defined(AFS_DARWIN_ENV)
struct lock__bsd__ afs_global_lock;
#elif defined(AFS_FBSD_ENV)
-struct simplelock afs_global_lock;
+struct lock afs_global_lock;
+struct proc *afs_global_owner;
#endif
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
thread_t afs_global_owner;
#endif /* AFS_OSF_ENV */
return code;
}
+#if defined(AFS_LINUX24_ENV) && defined(COMPLETION_H_EXISTS)
+struct afsd_thread_info {
+ unsigned long parm;
+ struct completion *complete;
+};
+
+static int afsd_thread(void *rock) {
+ struct afsd_thread_info *arg=rock;
+ unsigned long parm=arg->parm;
+#ifdef SYS_SETPRIORITY_EXPORTED
+ int (*sys_setpriority)(int,int,int) = sys_call_table[__NR_setpriority];
+#endif
+ daemonize(); /* doesn't do much, since we were forked from keventd, but
+ does call mm_release, which wakes up our parent (since it
+ used CLONE_VFORK) */
+ afs_osi_MaskSignals();
+ switch (parm) {
+ case AFSOP_START_RXCALLBACK:
+ sprintf(current->comm, "afs_cbstart");
+ AFS_GLOCK();
+ complete(arg->complete);
+ afs_CB_Running = 1;
+ while (afs_RX_Running != 2)
+ afs_osi_Sleep(&afs_RX_Running);
+ sprintf(current->comm, "afs_callback");
+ afs_RXCallBackServer();
+ AFS_GUNLOCK();
+ complete_and_exit(0,0);
+ break;
+ case AFSOP_START_AFS:
+ sprintf(current->comm, "afs_afsstart");
+ AFS_GLOCK();
+ complete(arg->complete);
+ AFS_Running = 1;
+ while (afs_initState < AFSOP_START_AFS)
+ afs_osi_Sleep(&afs_initState);
+ DInit(AFS_MINBUFFERS);
+ afs_initState = AFSOP_START_BKG;
+ afs_osi_Wakeup(&afs_initState);
+ sprintf(current->comm, "afsd");
+ afs_Daemon();
+ AFS_GUNLOCK();
+ complete_and_exit(0,0);
+ break;
+ case AFSOP_START_BKG:
+ sprintf(current->comm, "afs_bkgstart");
+ AFS_GLOCK();
+ complete(arg->complete);
+ while (afs_initState < AFSOP_START_BKG)
+ afs_osi_Sleep(&afs_initState);
+ if (afs_initState < AFSOP_GO) {
+ afs_initState = AFSOP_GO;
+ afs_osi_Wakeup(&afs_initState);
+ }
+ sprintf(current->comm, "afs_background");
+ afs_BackgroundDaemon();
+ AFS_GUNLOCK();
+ complete_and_exit(0,0);
+ break;
+ case AFSOP_START_TRUNCDAEMON:
+ sprintf(current->comm, "afs_trimstart");
+ AFS_GLOCK();
+ complete(arg->complete);
+ while (afs_initState < AFSOP_GO)
+ afs_osi_Sleep(&afs_initState);
+ sprintf(current->comm, "afs_cachetrim");
+ afs_CacheTruncateDaemon();
+ AFS_GUNLOCK();
+ complete_and_exit(0,0);
+ break;
+ case AFSOP_START_CS:
+ sprintf(current->comm, "afs_checkserver");
+ AFS_GLOCK();
+ complete(arg->complete);
+ afs_CheckServerDaemon();
+ AFS_GUNLOCK();
+ complete_and_exit(0,0);
+ break;
+ case AFSOP_RXEVENT_DAEMON:
+ sprintf(current->comm, "afs_evtstart");
+#ifdef SYS_SETPRIORITY_EXPORTED
+ sys_setpriority(PRIO_PROCESS,0,-10);
+#else
+#ifdef CURRENT_INCLUDES_NICE
+ current->nice=-10;
+#endif
+#endif
+ AFS_GLOCK();
+ complete(arg->complete);
+ while (afs_initState < AFSOP_START_BKG)
+ afs_osi_Sleep(&afs_initState);
+ sprintf(current->comm, "afs_rxevent");
+ afs_rxevent_daemon();
+ AFS_GUNLOCK();
+ complete_and_exit(0,0);
+ break;
+ case AFSOP_RXLISTENER_DAEMON:
+ sprintf(current->comm, "afs_lsnstart");
+#ifdef SYS_SETPRIORITY_EXPORTED
+ sys_setpriority(PRIO_PROCESS,0,-10);
+#else
+#ifdef CURRENT_INCLUDES_NICE
+ current->nice=-10;
+#endif
+#endif
+ AFS_GLOCK();
+ complete(arg->complete);
+ afs_initState = AFSOP_START_AFS;
+ afs_osi_Wakeup(&afs_initState);
+ afs_RX_Running = 2;
+ afs_osi_Wakeup(&afs_RX_Running);
+ afs_osi_RxkRegister();
+ sprintf(current->comm, "afs_rxlistener");
+ rxk_Listener();
+ AFS_GUNLOCK();
+ complete_and_exit(0,0);
+ break;
+ default:
+ printf("Unknown op %d in StartDaemon()\n");
+ break;
+ }
+ return 0;
+}
+
+void afsd_launcher(void *rock) {
+ if (!kernel_thread(afsd_thread,rock, CLONE_VFORK|SIGCHLD))
+ printf("kernel_thread failed. afs startup will not complete\n");
+}
+
+void afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
+ long parm6)
+{
+ int code;
+ DECLARE_COMPLETION(c);
+ struct tq_struct tq;
+ struct afsd_thread_info info;
+ if (parm == AFSOP_START_RXCALLBACK) {
+ if (afs_CB_Running) return;
+ } else if (parm == AFSOP_RXLISTENER_DAEMON) {
+ if (afs_RX_Running) return;
+ afs_RX_Running=1;
+ code = afs_InitSetup(parm2);
+ if (parm3) {
+ rx_enablePeerRPCStats();
+ }
+ if (parm4) {
+ rx_enableProcessRPCStats();
+ }
+ if (code)
+ return;
+ } else if (parm == AFSOP_START_AFS) {
+ if (AFS_Running) return;
+ } /* other functions don't need setup in the parent */
+ info.complete=&c;
+ info.parm=parm;
+ tq.sync=0;
+ INIT_LIST_HEAD(&tq.list);
+ tq.routine=afsd_launcher;
+ tq.data=&info;
+ schedule_task(&tq);
+ AFS_GUNLOCK();
+ /* we need to wait cause we passed stack pointers around.... */
+ wait_for_completion(&c);
+ AFS_GLOCK();
+}
+#endif
afs_syscall_call(parm, parm2, parm3, parm4, parm5, parm6)
long parm, parm2, parm3, parm4, parm5, parm6;
#endif
}
AFS_GLOCK();
+#if defined(AFS_LINUX24_ENV) && defined(COMPLETION_H_EXISTS) && !defined(UKERNEL)
+ if (parm < AFSOP_ADDCELL || parm == AFSOP_RXEVENT_DAEMON
+ || parm == AFSOP_RXLISTENER_DAEMON) {
+ afs_DaemonOp(parm,parm2,parm3,parm4,parm5,parm6);
+ }
+#else
if (parm == AFSOP_START_RXCALLBACK) {
if (afs_CB_Running) goto out;
afs_CB_Running = 1;
#endif
}
#endif
+#endif
else if (parm == AFSOP_ADDCELL) {
/* add a cell. Parameter 2 is 8 hosts (in net order), parm 3 is the null-terminated
name. Parameter 4 is the length of the name, including the null. Parm 5 is the
}
#else /* AFS_USERSPACE_IP_ADDR */
struct ifnet *tifnp;
+#ifdef AFS_DARWIN60_ENV
+ struct ifaddr *tifadp = (struct ifaddr *) 0;
+#else
struct in_ifaddr *tifadp = (struct in_ifaddr *) 0;
+#endif
extern struct ifnet *rxi_FindIfnet();
tifnp = rxi_FindIfnet(parm2, &tifadp); /* make iterative */
if (tifnp && tifadp) {
+#ifdef AFS_DARWIN60_ENV
+ mask = ((struct sockaddr_in *)tifadp->ifa_netmask)->sin_addr.s_addr;
+#else
mask = tifadp->ia_subnetmask;
+#endif
} else {
code = -1;
}
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_pioctl.c,v 1.14 2002/08/02 04:57:37 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_pioctl.c,v 1.15 2002/09/26 19:18:06 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
#endif /* AFS_SUN5_ENV */
#endif
#ifndef AFS_LINUX22_ENV
-#if defined(AFS_AIX32_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_AIX32_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
struct file *fd;
#else
register struct file *fd;
#endif
+#endif
+#if defined(AFS_FBSD_ENV)
+ register struct filedesc *fdp;
#endif
register struct vcache *tvc;
register int ioctlDone = 0, code = 0;
AFS_STATCNT(afs_xioctl);
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_FBSD_ENV)
+ fdp=p->p_fd;
+ if ((u_int)uap->fd >= fdp->fd_nfiles ||
+ (fd = fdp->fd_ofiles[uap->fd]) == NULL)
+ return EBADF;
+ if ((fd->f_flag & (FREAD | FWRITE)) == 0)
+ return EBADF;
+#else
+#if defined(AFS_DARWIN_ENV)
if ((code=fdgetf(p, uap->fd, &fd)))
return code;
#else
#endif
#endif
#endif
+#endif
#endif
/* first determine whether this is any sort of vnode */
#endif
code = ioctl(uap, rvp);
#else
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_FBSD_ENV)
+ return ioctl(p, uap);
+#else
+#if defined(AFS_DARWIN_ENV)
return ioctl(p, uap, retval);
#else
#ifdef AFS_OSF_ENV
#endif
#endif
#endif
+#endif
#endif
}
#ifdef AFS_SUN5_ENV
inData = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
if (inSize > 0) {
AFS_COPYIN(ablob->in, inData, inSize, code);
+ inData[inSize]='\0';
}
else code = 0;
if (code) {
if (code == 0 && ablob->out_size > 0) {
if (outSize > ablob->out_size) outSize = ablob->out_size;
if (outSize >= PIGGYSIZE) code = E2BIG;
- else if (outSize)
+ else if (outSize) {
+ outData[outSize]='\0';
AFS_COPYOUT(outData, ablob->out, outSize, code);
+ }
}
osi_FreeLargeSpace(outData);
afs_PutFakeStat(&fakestate);
else code = EPERM;
}
- if (avc && (sbr->sb_thisfile != -1))
+ if (avc && (sbr->sb_thisfile != -1)) {
if (afs_AccessOK(avc, PRSFS_WRITE | PRSFS_ADMINISTER,
areq, DONT_CHECK_MODE_BITS))
avc->asynchrony = sbr->sb_thisfile;
else code = EACCES;
+ }
*aoutSize = sizeof(struct sbstruct);
sbr = (struct sbstruct *)aout;
ain += sizeof(afs_int32);
stp = ain; /* remember where the ticket is */
if (i < 0 || i > 2000) return EINVAL; /* malloc may fail */
+ if (i > MAXKTCTICKETLEN) return EINVAL;
stLen = i;
ain += i; /* skip over ticket */
memcpy((char *)&i, ain, sizeof(afs_int32));
if (set_parent_pag) {
int pag;
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV)
struct proc *p=current_proc(); /* XXX */
+#else
+ struct proc *p=curproc; /* XXX */
+#endif
uprintf("Process %d (%s) tried to change pags in PSetTokens\n",
p->p_pid, p->p_comm);
if (!setpag(p, acred, -1, &pag, 1)) {
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bosoprocs.c,v 1.5 2002/05/12 05:50:43 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bosoprocs.c,v 1.6 2002/09/26 19:18:07 hartmans Exp $");
#include <afs/stds.h>
#include <sys/types.h>
for (i=0; i<bozo_nbosEntryStats; i++) {
struct bozo_bosEntryStats *e = &bozo_bosEntryStats[i];
if (!StatEachEntry (e)) {
+ bozo_Log("unhappy with %s which is a %s that should "
+ "have at least rights %o, at most rights %o %s\n",
+ e->path,
+ e->dir ? "dir" : "file",
+ e->reqPerm,
+ e->proPerm,
+ e->rootOwner ? ", owned by root" : "");
result = 0;
break;
}
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
#if !defined(KERNEL) && !defined(_KMEMUSER) && !defined(AFS_PTHREAD_ENV)
#include <afs/param.h>
-#ifdef HAVE_UCONTEXT_H
+#if defined(USE_UCONTEXT) && defined(HAVE_UCONTEXT_H)
#include <ucontext.h>
#else
#include <setjmp.h>
#else
struct lwp_context { /* saved context for dispatcher */
char *topstack; /* ptr to top of process stack */
-#ifdef HAVE_UCONTEXT_H
+#if defined(USE_UCONTEXT) && defined(HAVE_UCONTEXT_H)
ucontext_t ucontext;
int state;
#else /* !HAVE_UCONTEXT_H */
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/lwp/preempt.c,v 1.9 2001/09/20 06:47:46 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/lwp/preempt.c,v 1.10 2002/09/26 19:18:08 hartmans Exp $");
#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) || defined(AFS_DJGPP_ENV)
#else
#include <sys/time.h>
#include <signal.h>
+#ifdef HAVE_UCONTEXT_H
#include <ucontext.h>
+#endif
#include "lwp.h"
#include "preempt.h"
char PRE_Block = 0; /* used in lwp.c and process.s */
#endif
+#if HAVE_SIGACTION && defined(SA_SIGINFO)
static void AlarmHandler(sig, st, scp)
int sig;
siginfo_t *st;
ucontext_t *scp;
+#else
+static void AlarmHandler(sig, code, scp)
+ int sig, code;
+ struct sigcontext *scp;
+#endif
{
if (PRE_Block == 0 && lwp_cpptr->level == 0)
{
PRE_BeginCritical();
+#if HAVE_SIGACTION && defined(SA_SIGINFO)
sigprocmask(SIG_SETMASK, &scp->uc_sigmask, NULL);
+#else
+ sigsetmask(scp->sc_mask);
+#endif
LWP_DispatchProcess();
PRE_EndCritical();
}
struct timeval *slice;
{
struct itimerval itv;
+#if HAVE_SIGACTION && defined(SA_SIGINFO)
struct sigaction action;
+#else
+ struct sigvec vec;
+#endif
if (lwp_cpptr == 0) return (LWP_EINIT);
itv.it_interval = itv.it_value = *slice;
}
+#if HAVE_SIGACTION && defined(SA_SIGINFO)
memset((char *)&action, 0, sizeof(action));
action.sa_sigaction = AlarmHandler;
action.sa_flags = SA_SIGINFO;
if ((sigaction(SIGALRM, &action, (struct sigaction *)0) == -1) ||
(setitimer(ITIMER_REAL, &itv, (struct itimerval *) 0) == -1))
return(LWP_ESYSTEM);
+#else
+ memset((char *)&vec, 0, sizeof(vec));
+ vec.sv_handler = AlarmHandler;
+ vec.sv_mask = vec.sv_onstack = 0;
+
+ if ((sigvec(SIGALRM, &vec, (struct sigvec *)0) == -1) ||
+ (setitimer(ITIMER_REAL, &itv, (struct itimerval *) 0) == -1))
+ return(LWP_ESYSTEM);
+#endif
return(LWP_SUCCESS);
}
int PRE_EndPreempt()
{
struct itimerval itv;
+#if HAVE_SIGACTION && defined(SA_SIGINFO)
struct sigaction action;
+#else
+ struct sigvec vec;
+#endif
if (lwp_cpptr == 0) return (LWP_EINIT);
itv.it_value.tv_sec = itv.it_value.tv_usec = 0;
+#if HAVE_SIGACTION && defined(SA_SIGINFO)
memset((char *)&action, 0, sizeof(action));
action.sa_handler = SIG_DFL;
if ((setitimer(ITIMER_REAL, &itv, (struct itimerval *) 0) == -1) ||
(sigaction(SIGALRM, &action, (struct sigaction *)0) == -1))
return(LWP_ESYSTEM);
+#else
+ memset((char *)&vec, 0, sizeof(vec));
+ vec.sv_handler = SIG_DFL;
+ vec.sv_mask = vec.sv_onstack = 0;
+
+ if ((setitimer(ITIMER_REAL, &itv, (struct itimerval *) 0) == -1) ||
+ (sigvec(SIGALRM, &vec, (struct sigvec *)0) == -1))
+ return(LWP_ESYSTEM);
+#endif
return(LWP_SUCCESS);
}
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/lwp/process.c,v 1.9 2002/02/25 19:53:25 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/lwp/process.c,v 1.10 2002/09/26 19:18:08 hartmans Exp $");
#include <stdio.h>
#include <assert.h>
extern char PRE_Block; /* used in lwp.c and process.s */
#endif
-#ifdef HAVE_UCONTEXT_H
+#if defined(USE_UCONTEXT) && defined(HAVE_UCONTEXT_H)
afs_int32
savecontext(ep, savearea, newsp)
#include <afs/param.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx.c,v 1.11 2002/01/30 16:54:11 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx.c,v 1.12 2002/09/26 19:18:08 hartmans Exp $");
#ifdef KERNEL
#include "../afs/sysincludes.h"
struct rx_connection *rxLastConn = 0;
#ifdef RX_ENABLE_LOCKS
-/* The locking hierarchy for rx fine grain locking is composed of five
+/* The locking hierarchy for rx fine grain locking is composed of these
* tiers:
+ *
+ * rx_connHashTable_lock - synchronizes conn creation, rx_connHashTable access
* conn_call_lock - used to synchonize rx_EndCall and rx_NewCall
* call->lock - locks call data fields.
- * Most any other lock - these are all independent of each other.....
- * rx_freePktQ_lock
+ * These are independent of each other:
* rx_freeCallQueue_lock
- * freeSQEList_lock
- * rx_connHashTable_lock
- * rx_serverPool_lock
* rxi_keyCreate_lock
+ * rx_serverPool_lock
+ * freeSQEList_lock
+ *
+ * serverQueueEntry->lock
+ * rx_rpc_stats
* rx_peerHashTable_lock - locked under rx_connHashTable_lock
-
+ * peer->lock - locks peer data fields.
+ * conn_data_lock - that more than one thread is not updating a conn data
+ * field at the same time.
+ * rx_freePktQ_lock
+ *
* lowest level:
- * peer_lock - locks peer data fields.
- * conn_data_lock - that more than one thread is not updating a conn data
- * field at the same time.
+ * multi_handle->lock
+ * rxevent_lock
+ * rx_stats_mutex
+ *
* Do we need a lock to protect the peer field in the conn structure?
* conn->peer was previously a constant for all intents and so has no
* lock protecting this field. The multihomed client delta introduced
#ifdef RX_LOCKS_DB
rxdb_init();
#endif /* RX_LOCKS_DB */
- MUTEX_INIT(&rx_stats_mutex, "rx_stats_mutex",MUTEX_DEFAULT,0);
- MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats",MUTEX_DEFAULT,0);
- MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock",MUTEX_DEFAULT,0);
+ MUTEX_INIT(&rx_stats_mutex, "rx_stats_mutex",MUTEX_DEFAULT,0);
+ MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats",MUTEX_DEFAULT,0);
+ MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock",MUTEX_DEFAULT,0);
MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock",MUTEX_DEFAULT,0);
MUTEX_INIT(&rx_freeCallQueue_lock, "rx_freeCallQueue_lock",
MUTEX_DEFAULT,0);
/* Make sure the connection is completely reset before deleting it. */
/* get rid of pending events that could zap us later */
- if (conn->challengeEvent) {
+ if (conn->challengeEvent)
rxevent_Cancel(conn->challengeEvent, (struct rx_call*)0, 0);
- }
+ if (conn->checkReachEvent)
+ rxevent_Cancel(conn->checkReachEvent, (struct rx_call*)0, 0);
/* Add the connection to the list of destroyed connections that
* need to be cleaned up. This is necessary to avoid deadlocks
service->idleDeadTime = 60;
service->connDeadTime = rx_connDeadTime;
service->executeRequestProc = serviceProc;
+ service->checkReach = 0;
rx_services[i] = service; /* not visible until now */
AFS_RXGUNLOCK();
USERPRI;
} else { /* otherwise allocate a new one and return that */
MUTEX_EXIT(&freeSQEList_lock);
sq = (struct rx_serverQueueEntry *) rxi_Alloc(sizeof(struct rx_serverQueueEntry));
- MUTEX_INIT(&sq->lock, "server Queue lock",MUTEX_DEFAULT,0);
+ MUTEX_INIT(&sq->lock, "server Queue lock",MUTEX_DEFAULT,0);
CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
}
} else { /* otherwise allocate a new one and return that */
MUTEX_EXIT(&freeSQEList_lock);
sq = (struct rx_serverQueueEntry *) rxi_Alloc(sizeof(struct rx_serverQueueEntry));
- MUTEX_INIT(&sq->lock, "server Queue lock",MUTEX_DEFAULT,0);
+ MUTEX_INIT(&sq->lock, "server Queue lock",MUTEX_DEFAULT,0);
CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
}
MUTEX_ENTER(&sq->lock);
addr.sin_family = AF_INET;
addr.sin_port = port;
addr.sin_addr.s_addr = host;
-#if defined(AFS_OSF_ENV) && defined(_KERNEL)
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
addr.sin_len = sizeof(addr);
-#endif /* AFS_OSF_ENV */
+#endif /* STRUCT_SOCKADDR_HAS_SA_LEN */
drop = (*rx_justReceived) (np, &addr);
/* drop packet if return value is non-zero */
if (drop) return np;
MUTEX_ENTER(&conn->conn_data_lock);
if (conn->maxSerial < np->header.serial)
- conn->maxSerial = np->header.serial;
+ conn->maxSerial = np->header.serial;
MUTEX_EXIT(&conn->conn_data_lock);
/* If the connection is in an error state, send an abort packet and ignore
return np;
}
if (!call) {
+ MUTEX_ENTER(&conn->conn_call_lock);
call = rxi_NewCall(conn, channel);
+ MUTEX_EXIT(&conn->conn_call_lock);
*call->callNumber = np->header.callNumber;
call->state = RX_STATE_PRECALL;
clock_GetTime(&call->queueTime);
}
#endif /* KERNEL */
+static void rxi_CheckReachEvent(event, conn, acall)
+ struct rxevent *event;
+ struct rx_connection *conn;
+ struct rx_call *acall;
+{
+ struct rx_call *call = acall;
+ struct clock when;
+ int i, waiting;
+
+ MUTEX_ENTER(&conn->conn_data_lock);
+ conn->checkReachEvent = (struct rxevent *) 0;
+ waiting = conn->flags & RX_CONN_ATTACHWAIT;
+ if (event) conn->refCount--;
+ MUTEX_EXIT(&conn->conn_data_lock);
+
+ if (waiting) {
+ if (!call) {
+ MUTEX_ENTER(&conn->conn_call_lock);
+ MUTEX_ENTER(&conn->conn_data_lock);
+ for (i=0; i<RX_MAXCALLS; i++) {
+ struct rx_call *tc = conn->call[i];
+ if (tc && tc->state == RX_STATE_PRECALL) {
+ call = tc;
+ break;
+ }
+ }
+ if (!call)
+ /* Indicate that rxi_CheckReachEvent is no longer running by
+ * clearing the flag. Must be atomic under conn_data_lock to
+ * avoid a new call slipping by: rxi_CheckConnReach holds
+ * conn_data_lock while checking RX_CONN_ATTACHWAIT.
+ */
+ conn->flags &= ~RX_CONN_ATTACHWAIT;
+ MUTEX_EXIT(&conn->conn_data_lock);
+ MUTEX_EXIT(&conn->conn_call_lock);
+ }
+
+ if (call) {
+ if (call != acall) MUTEX_ENTER(&call->lock);
+ rxi_SendAck(call, NULL, 0, 0, 0, RX_ACK_PING, 0);
+ if (call != acall) MUTEX_EXIT(&call->lock);
+
+ clock_GetTime(&when);
+ when.sec += RX_CHECKREACH_TIMEOUT;
+ MUTEX_ENTER(&conn->conn_data_lock);
+ if (!conn->checkReachEvent) {
+ conn->refCount++;
+ conn->checkReachEvent =
+ rxevent_Post(&when, rxi_CheckReachEvent, conn, NULL);
+ }
+ MUTEX_EXIT(&conn->conn_data_lock);
+ }
+ }
+}
+
+static int rxi_CheckConnReach(conn, call)
+ struct rx_connection *conn;
+ struct rx_call *call;
+{
+ struct rx_service *service = conn->service;
+ struct rx_peer *peer = conn->peer;
+ afs_uint32 now, lastReach;
+
+ if (service->checkReach == 0)
+ return 0;
+
+ now = clock_Sec();
+ MUTEX_ENTER(&peer->peer_lock);
+ lastReach = peer->lastReachTime;
+ MUTEX_EXIT(&peer->peer_lock);
+ if (now - lastReach < RX_CHECKREACH_TTL)
+ return 0;
+
+ MUTEX_ENTER(&conn->conn_data_lock);
+ if (conn->flags & RX_CONN_ATTACHWAIT) {
+ MUTEX_EXIT(&conn->conn_data_lock);
+ return 1;
+ }
+ conn->flags |= RX_CONN_ATTACHWAIT;
+ MUTEX_EXIT(&conn->conn_data_lock);
+ if (!conn->checkReachEvent)
+ rxi_CheckReachEvent((struct rxevent *)0, conn, call);
+
+ return 1;
+}
+
/* try to attach call, if authentication is complete */
-static void TryAttach(acall, socket, tnop, newcallp)
-register struct rx_call *acall;
-register osi_socket socket;
-register int *tnop;
-register struct rx_call **newcallp; {
- register struct rx_connection *conn;
- conn = acall->conn;
- if ((conn->type==RX_SERVER_CONNECTION) && (acall->state == RX_STATE_PRECALL)) {
+static void TryAttach(acall, socket, tnop, newcallp, reachOverride)
+ register struct rx_call *acall;
+ register osi_socket socket;
+ register int *tnop;
+ register struct rx_call **newcallp;
+ int reachOverride;
+{
+ struct rx_connection *conn = acall->conn;
+
+ if (conn->type==RX_SERVER_CONNECTION && acall->state==RX_STATE_PRECALL) {
/* Don't attach until we have any req'd. authentication. */
if (RXS_CheckAuthentication(conn->securityObject, conn) == 0) {
- rxi_AttachServerProc(acall, socket, tnop, newcallp);
- /* Note: this does not necessarily succeed; there
- may not any proc available */
+ if (reachOverride || rxi_CheckConnReach(conn, acall) == 0)
+ rxi_AttachServerProc(acall, socket, tnop, newcallp);
+ /* Note: this does not necessarily succeed; there
+ * may not any proc available
+ */
}
else {
rxi_ChallengeOn(acall->conn);
* server thread is available, this thread becomes a server
* thread and the server thread becomes a listener thread. */
if (isFirst) {
- TryAttach(call, socket, tnop, newcallp);
+ TryAttach(call, socket, tnop, newcallp, 0);
}
}
/* This is not the expected next packet. */
static void rxi_ComputeRate();
#endif
+static void rxi_UpdatePeerReach(conn, acall)
+ struct rx_connection *conn;
+ struct rx_call *acall;
+{
+ struct rx_peer *peer = conn->peer;
+
+ MUTEX_ENTER(&peer->peer_lock);
+ peer->lastReachTime = clock_Sec();
+ MUTEX_EXIT(&peer->peer_lock);
+
+ MUTEX_ENTER(&conn->conn_data_lock);
+ if (conn->flags & RX_CONN_ATTACHWAIT) {
+ int i;
+
+ conn->flags &= ~RX_CONN_ATTACHWAIT;
+ MUTEX_EXIT(&conn->conn_data_lock);
+
+ for (i=0; i<RX_MAXCALLS; i++) {
+ struct rx_call *call = conn->call[i];
+ if (call) {
+ if (call != acall) MUTEX_ENTER(&call->lock);
+ TryAttach(call, -1, NULL, NULL, 1);
+ if (call != acall) MUTEX_EXIT(&call->lock);
+ }
+ }
+ } else
+ MUTEX_EXIT(&conn->conn_data_lock);
+}
+
/* The real smarts of the whole thing. */
struct rx_packet *rxi_ReceiveAckPacket(call, np, istack)
register struct rx_call *call;
if (np->header.flags & RX_SLOW_START_OK) {
call->flags |= RX_CALL_SLOW_START_OK;
}
+
+ if (ap->reason == RX_ACK_PING_RESPONSE)
+ rxi_UpdatePeerReach(conn, call);
#ifdef RXDEBUG
if (rx_Log) {
}
else {
/* If the response is valid, any calls waiting to attach
- * servers can now do so */
+ * servers can now do so */
int i;
+
for (i=0; i<RX_MAXCALLS; i++) {
struct rx_call *call = conn->call[i];
if (call) {
MUTEX_EXIT(&call->lock);
}
}
+
+ /* Update the peer reachability information, just in case
+ * some calls went into attach-wait while we were waiting
+ * for authentication..
+ */
+ rxi_UpdatePeerReach(conn, NULL);
}
return np;
}
* call so it eventually gets one */
void
rxi_AttachServerProc(call, socket, tnop, newcallp)
-register struct rx_call *call;
-register osi_socket socket;
-register int *tnop;
-register struct rx_call **newcallp;
+ register struct rx_call *call;
+ register osi_socket socket;
+ register int *tnop;
+ register struct rx_call **newcallp;
{
register struct rx_serverQueueEntry *sq;
register struct rx_service *service = call->conn->service;
{
if (error) {
register int i;
+ MUTEX_ENTER(&conn->conn_data_lock);
if (conn->challengeEvent)
rxevent_Cancel(conn->challengeEvent, (struct rx_call*)0, 0);
+ if (conn->checkReachEvent) {
+ rxevent_Cancel(conn->checkReachEvent, (struct rx_call*)0, 0);
+ conn->checkReachEvent = 0;
+ conn->flags &= ~RX_CONN_ATTACHWAIT;
+ conn->refCount--;
+ }
+ MUTEX_EXIT(&conn->conn_data_lock);
for (i=0; i<RX_MAXCALLS; i++) {
struct rx_call *call = conn->call[i];
if (call) {
taddr.sin_family = AF_INET;
taddr.sin_port = remotePort;
taddr.sin_addr.s_addr = remoteAddr;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
while(1) {
memset(&theader, 0, sizeof(theader));
theader.epoch = htonl(999);
#include <afs/param.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx_packet.c,v 1.6 2001/10/14 18:43:30 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx_packet.c,v 1.7 2002/09/26 19:18:09 hartmans Exp $");
#ifdef KERNEL
#if defined(UKERNEL)
#include "../afs/sysincludes.h"
#endif
#include "../h/socket.h"
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
+#if !defined(AFS_OSF_ENV) && !defined(AFS_AIX41_ENV)
+#include "../sys/mount.h" /* it gets pulled in by something later anyway */
+#endif
+#include "../h/mbuf.h"
+#endif
#include "../netinet/in.h"
#include "../afs/afs_osi.h"
#include "../rx/rx_kmutex.h"
#include <sys/sysmacros.h>
#endif
#include "../rx/rx_packet.h"
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
-#if !defined(AFS_OSF_ENV) && !defined(AFS_AIX41_ENV)
-#include "../sys/mount.h" /* it gets pulled in by something later anyway */
-#endif
-#include "../h/mbuf.h"
-#endif
#endif /* defined(UKERNEL) */
#include "../rx/rx_globals.h"
#else /* KERNEL */
taddr.sin_family = AF_INET;
taddr.sin_port = aport;
taddr.sin_addr.s_addr = ahost;
-
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
/* We need to trim the niovecs. */
nbytes = apacket->length;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/viced/afsfileprocs.c,v 1.9 2002/06/10 12:02:03 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/viced/afsfileprocs.c,v 1.10 2002/09/26 19:18:09 hartmans Exp $");
#include <stdio.h>
#include <stdlib.h>
}
else { /* store data or status */
/* watch for chowns and chgrps */
- if (CHOWN(InStatus, targetptr) || CHGRP(InStatus, targetptr))
- return(EPERM); /* Was EACCES */
+ if (CHOWN(InStatus, targetptr) || CHGRP(InStatus, targetptr)) {
+ if (VanillaUser (client))
+ return(EPERM); /* Was EACCES */
+ else
+ osi_audit(PrivilegeEvent, 0,
+ AUD_INT, (client ? client->ViceId : 0),
+ AUD_INT, CallingRoutine, AUD_END);
+ }
/* must be sysadmin to set suid/sgid bits */
if ((InStatus->Mask & AFS_SETMODE) &&
#ifdef AFS_NT40_ENV
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/vol/partition.c,v 1.11 2002/08/02 04:57:39 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/vol/partition.c,v 1.12 2002/09/26 19:18:09 hartmans Exp $");
#include <ctype.h>
#ifdef AFS_NT40_ENV
#else
#if defined(AFS_SUN_ENV)
#include <sys/vfs.h>
+#ifndef AFS_SUN5_ENV
+#include <mntent.h>
+#endif
#endif
#ifdef AFS_SUN5_ENV
#include <unistd.h>
continue; /* Ignore any "special" partitions */
#ifdef AFS_AIX42_ENV
+#ifndef AFS_NAMEI_ENV
{
struct superblock fs;
/* The Log statements are non-sequiters in the SalvageLog and don't
continue;
}
}
+#endif
#endif
/* If we're going to always attach this partition, do it later. */
projects / packages / o / openafs.git / commitdiff