#include <afsconfig.h>
#include "afs/param.h"
-
-
#ifdef UKERNEL
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include <net/if.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <dirent.h>
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs_usrops.h"
#include "afs/auth.h"
#include "afs/cellconfig.h"
#include "afs/vice.h"
+#include "afs/kauth.h"
#include "afs/kautils.h"
#include "afs/afsutil.h"
#include "rx/rx_globals.h"
struct afs_cacheParams cparams; /* params passed to cache manager */
struct afsconf_dir *afs_cdir; /* config dir */
-static int HandleMTab();
-
int afs_bufferpages = 100;
int usr_udpcksum = 0;
afs_osi_Read(struct osi_file *fp, int offset, void *buf, afs_int32 len)
{
int rc, ret;
- int code;
struct stat st;
AFS_ASSERT_GLOCK();
afs_osi_Write(struct osi_file *fp, afs_int32 offset, void *buf, afs_int32 len)
{
int rc, ret;
- int code;
struct stat st;
AFS_ASSERT_GLOCK();
return 0;
}
-/*
- * Use malloc/free routines with check patterns before and after each block
- */
-
-static char *afs_check_string1 = "UAFS";
-static char *afs_check_string2 = "AFS_OSI_";
-
void *
afs_osi_Alloc(size_t size)
{
}
int
-afs_osi_MapStrategy(int (*aproc) (), struct usr_buf *bp)
+afs_osi_MapStrategy(int (*aproc) (struct usr_buf *), struct usr_buf *bp)
{
afs_int32 returnCode;
returnCode = (*aproc) (bp);
osi_Init(void)
{
int i;
- int rc;
- usr_thread_t tid;
/*
* Allocate the table used to implement psuedo-inodes.
int nDaemonsParam, int cacheFlagsParam, char *logFile)
{
int st;
- struct usr_proc *procp;
- struct usr_ucred *ucredp;
int i;
int rc;
int currVFile; /* Current AFS cache file number */
int cacheIteration; /* cache verification loop counter */
int vFilesFound; /* Num data cache files found in sweep */
FILE *logfd;
- afs_int32 vfs1_type = -1;
- struct afs_ioctl iob;
char tbuffer[1024];
char *p;
char lastchar;
}
memset(pathname_for_V, 0, (cacheFiles * sizeof(char *)));
if (afsd_debug)
- printf("%s: %d pathname_for_V entries at 0x%x, %d bytes\n", rn,
- cacheFiles, pathname_for_V, (cacheFiles * sizeof(AFSD_INO_T)));
+ printf("%s: %d pathname_for_V entries at %" AFS_PTR_FMT
+ ", %lud bytes\n", rn, cacheFiles, pathname_for_V,
+ afs_printable_uint32_lu(cacheFiles * sizeof(AFSD_INO_T)));
/*
* Set up all the pathnames we'll need for later.
return 0;
}
+int
fork_syscall(syscall, afscall, param1, param2, param3, param4)
long syscall, afscall, param1, param2, param3, param4;
{
return 0;
}
+int
call_syscall(syscall, afscall, param1, param2, param3, param4)
long syscall, afscall, param1, param2, param3, param4;
{
struct usr_vnode *vp;
struct usr_vnode *nextVp;
struct usr_vnode *linkVp;
+ struct vcache *nextVc;
char *tmpPath;
char *pathP;
char *nextPathP = NULL;
* lookup the next component in the path, we can release the
* subdirectory since we hold the global lock
*/
+ nextVc = NULL;
nextVp = NULL;
#ifdef AFS_WEB_ENHANCEMENTS
if ((nextPathP != NULL && *nextPathP != '\0') || !no_eval_mtpt)
- code = afs_lookup(vp, pathP, &nextVp, u.u_cred, 0);
+ code = afs_lookup(VTOAFS(vp), pathP, &nextVc, u.u_cred, 0);
else
code =
- afs_lookup(vp, pathP, &nextVp, u.u_cred,
+ afs_lookup(VTOAFS(vp), pathP, &nextVc, u.u_cred,
AFS_LOOKUP_NOEVAL);
#else
- code = afs_lookup(vp, pathP, &nextVp, u.u_cred, 0);
+ code = afs_lookup(VTOAFS(vp), pathP, &nextVc, u.u_cred, 0);
#endif /* AFS_WEB_ENHANCEMENTS */
+ if (nextVc)
+ nextVp=AFSTOV(nextVc);
if (code != 0) {
VN_RELE(vp);
afs_osi_Free(tmpPath, strlen(path) + 1);
/*
* Read the link data
*/
- code = afs_readlink(vp, &uio, u.u_cred);
+ code = afs_readlink(VTOAFS(vp), &uio, u.u_cred);
if (code) {
afs_osi_Free(pathP, MAX_OSI_PATH + 1);
return code;
int code;
char *nameP;
struct vnode *parentP;
- struct vnode *dirP;
+ struct vcache *dirP;
struct usr_vattr attrs;
if (uafs_IsRoot(path)) {
attrs.va_uid = u.u_cred->cr_uid;
attrs.va_gid = u.u_cred->cr_gid;
dirP = NULL;
- code = afs_mkdir(parentP, nameP, &attrs, &dirP, u.u_cred);
+ code = afs_mkdir(VTOAFS(parentP), nameP, &attrs, &dirP, u.u_cred);
VN_RELE(parentP);
if (code != 0) {
errno = code;
return -1;
}
- VN_RELE(dirP);
+ VN_RELE(AFSTOV(dirP));
return 0;
}
return -1;
}
- code = afs_fsync(fileP, u.u_cred);
+ code = afs_fsync(VTOAFS(fileP), u.u_cred);
if (code != 0) {
errno = code;
return -1;
}
afs_FileTable[fd] = NULL;
- code = afs_close(fileP, afs_FileFlags[fd], u.u_cred);
+ code = afs_close(VTOAFS(fileP), afs_FileFlags[fd], u.u_cred);
VN_RELE(fileP);
if (code != 0) {
errno = code;
/*
* Create the link
*/
- code = afs_link(existP, dirP, nameP, u.u_cred);
+ code = afs_link(VTOAFS(existP), VTOAFS(dirP), nameP, u.u_cred);
VN_RELE(existP);
VN_RELE(dirP);
if (code != 0) {
attrs.va_mode = 0777;
attrs.va_uid = u.u_cred->cr_uid;
attrs.va_gid = u.u_cred->cr_gid;
- code = afs_symlink(dirP, nameP, &attrs, target, u.u_cred);
+ code = afs_symlink(VTOAFS(dirP), nameP, &attrs, target, u.u_cred);
VN_RELE(dirP);
if (code != 0) {
errno = code;
/*
* Read the the link
*/
- code = afs_readlink(vp, &uio, u.u_cred);
+ code = afs_readlink(VTOAFS(vp), &uio, u.u_cred);
VN_RELE(vp);
if (code) {
errno = code;
uafs_unlink_r(char *path)
{
int code;
- int openFlags;
- struct usr_vnode *fileP;
struct usr_vnode *dirP;
char *nameP;
/*
* Remove the file
*/
- code = afs_remove(dirP, nameP, u.u_cred);
+ code = afs_remove(VTOAFS(dirP), nameP, u.u_cred);
VN_RELE(dirP);
if (code != 0) {
errno = code;
/*
* Rename the file
*/
- code = afs_rename(odirP, onameP, ndirP, nnameP, u.u_cred);
+ code = afs_rename(VTOAFS(odirP), onameP, VTOAFS(ndirP), nnameP, u.u_cred);
VN_RELE(odirP);
VN_RELE(ndirP);
if (code != 0) {
uafs_rmdir_r(char *path)
{
int code;
- int openFlags;
- struct usr_vnode *fileP;
struct usr_vnode *dirP;
char *nameP;
/*
* Remove the directory
*/
- code = afs_rmdir(dirP, nameP, u.u_cred);
+ code = afs_rmdir(VTOAFS(dirP), nameP, u.u_cred);
VN_RELE(dirP);
if (code != 0) {
errno = code;
/*
* read the next chunk from the directory
*/
- code = afs_readdir(vp, &uio, u.u_cred);
+ code = afs_readdir(VTOAFS(vp), &uio, u.u_cred);
if (code != 0) {
errno = code;
return -1;
struct usr_dirent *
uafs_readdir_r(usr_DIR * dirp)
{
- int rc;
int code;
int len;
struct usr_uio uio;
/*
* read the next chunk from the directory
*/
- code = afs_readdir(vp, &uio, u.u_cred);
+ code = afs_readdir(VTOAFS(vp), &uio, u.u_cred);
if (code != 0) {
errno = code;
return NULL;
uafs_statmountpoint(char *path)
{
int retval;
- int code;
- char buf[256];
AFS_GLOCK();
retval = uafs_statmountpoint_r(path);
int code;
struct vnode *vp;
struct vcache *avc;
- struct vrequest treq;
int r;
code = uafs_LookupName(path, afs_CurrentDir, &vp, 0, 1);
int
uafs_getRights(char *path)
{
- int code, rc;
+ int code;
struct vnode *vp;
int afs_rights;
PRSFS_READ | PRSFS_WRITE | PRSFS_INSERT | PRSFS_LOOKUP | PRSFS_DELETE
| PRSFS_LOCK | PRSFS_ADMINISTER;
- afs_rights = afs_getRights(vp, afs_rights, u.u_cred);
+ afs_rights = afs_getRights(VTOAFS(vp), afs_rights, u.u_cred);
AFS_GUNLOCK();
return afs_rights;
extern int uafs_RPCStatsDisableProc(void);
extern int uafs_RPCStatsEnablePeer(void);
extern int uafs_RPCStatsDisablePeer(void);
+extern int uafs_IsRoot(char *path);
+extern int uafs_statmountpoint_r(char *path);
#endif /* __AFS_USROPS_H__ */
int
-afs_xsetgroups()
+afs_xsetgroups(void)
{
usr_assert(0);
return 0;
afs_setgroups(struct AFS_UCRED **cred, int ngroups, gid_t * gidset,
int change_parent)
{
- int ngrps;
- int i;
gid_t *gp;
AFS_STATCNT(afs_setgroups);
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* statistics stuff */
+int afs_statfs(register struct vfs *afsp, struct statfs *abp);
+int afs_sync(struct vfs *afsp);
-int afs_mount();
-int afs_unmount();
-int afs_root();
-int afs_statfs();
-int afs_sync();
struct vfsops Afs_vfsops = {
afs_mount,
#include "sys/syscall.h"
#endif
-afs_mount(afsp, path, data)
- char *path;
- caddr_t data;
- struct vfs *afsp;
+int
+afs_mount(struct vfs *path, char *data, struct vfs *afsp)
{
AFS_STATCNT(afs_mount);
return 0;
}
-afs_unmount(afsp)
- struct vfs *afsp;
+int
+afs_unmount(struct vfs *afsp)
{
AFS_STATCNT(afs_unmount);
afs_globalVFS = 0;
return 0;
}
-afs_root(OSI_VFS_ARG(afsp), avpp)
- OSI_VFS_DECL(afsp);
- struct vnode **avpp;
+int
+afs_root(OSI_VFS_DECL(afsp), struct vnode **avpp)
{
register afs_int32 code = 0;
struct vrequest treq;
return code;
}
-afs_sync(afsp)
- struct vfs *afsp;
+int
+afs_sync(struct vfs *afsp)
{
AFS_STATCNT(afs_sync);
return 0;
}
-afs_statfs(afsp, abp)
- register struct vfs *afsp;
- struct statfs *abp;
+int
+afs_statfs(register struct vfs *afsp, struct statfs *abp)
{
AFS_STATCNT(afs_statfs);
abp->f_type = 0;
return 0;
}
-afs_mountroot()
+int
+afs_mountroot(void)
{
AFS_STATCNT(afs_mountroot);
return (EINVAL);
}
-afs_swapvp()
+int
+afs_swapvp(void)
{
AFS_STATCNT(afs_swapvp);
return (EINVAL);
int
afs_inactive(struct vcache *avc, struct AFS_UCRED *acred)
{
- struct vnode *vp = AFSTOV(avc);
if (afs_shuttingdown)
- return;
+ return 0;
usr_assert(avc->vrefCount == 0);
afs_InactiveVCache(avc, acred);
+
+ return 0;
}
struct usr_vnodeops Afs_vnodeops = {
#endif
#include <stdlib.h>
#include <string.h>
-#include <unistd.h>
-#include <dirent.h>
#include <limits.h>
#include <assert.h>
#include <stdarg.h>
+
#if !defined(AFS_USR_DARWIN_ENV) && !defined(AFS_USR_FBSD_ENV) /* must be included after KERNEL undef'd */
-#include <setjmp.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <setjmp.h>
#endif
#ifdef AFS_USR_SUN5_ENV
#include <signal.h>
#include <sys/param.h>
-#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/sockio.h>
#ifdef AFS_USR_AIX_ENV
#include <sys/param.h>
-#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <fcntl.h>
#ifdef AFS_USR_SGI_ENV
#include <sys/param.h>
-#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/sockio.h>
#ifdef AFS_USR_HPUX_ENV
#include <sys/param.h>
-#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/file.h>
#define AFS_USR_UNDEF_KERNEL_ENV 1
#endif
#include <sys/param.h>
-#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/file.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
+#include <dirent.h>
+#include <ctype.h>
+#include <unistd.h>
#ifndef O_SYNC
#define O_SYNC O_FSYNC
#endif
AFS_ASSERT_GLOCK(); \
usr_assert((vp)->v_count > 0); \
if (--((vp)->v_count) == 0) \
- afs_inactive(vp, u.u_cred); \
+ afs_inactive(VTOAFS(vp), u.u_cred); \
} while(0)
struct usr_statfs {
struct usr_vnodeops {
- int (*vn_open) (char *path, int flags, int mode);
- int (*vn_close) (int fd);
+ int (*vn_open) (struct vcache **, afs_int32, struct AFS_UCRED *);
+ int (*vn_close) (struct vcache *, afs_int32, struct AFS_UCRED *);
int (*vn_rdwr) (struct usr_vnode *avc, struct usr_uio *uio,
int rw, int io, struct usr_ucred *cred);
int (*vn_ioctl) (void);
typedef long usr_whymountroot_t;
struct usr_vfsops {
- int (*vfs_mount) (struct vfs *, char *, caddr_t);
+ int (*vfs_mount) (struct vfs *, char *, struct vfs *);
int (*vfs_unmount) (struct vfs *);
int (*vfs_root) (struct vfs *, struct vnode **);
int (*vfs_statfs) (struct vfs *, struct statfs *);
struct vrequest treq;
OSI_VC_CONVERT(avc);
- if (code = afs_InitReq(&treq, acred))
+ if ((code = afs_InitReq(&treq, acred)))
return code;
code = afs_VerifyVCache(avc, &treq);
register struct afs_conn *tc;
struct VenusFid newFid;
register struct dcache *tdc;
+#ifdef AFS_DISCON_ENV
struct dcache *new_dc;
+#endif
afs_size_t offset, len;
register struct vcache *tvc;
struct AFSStoreStatus InStatus;
done:
AFS_DISCON_UNLOCK();
- done3:
afs_PutFakeStat(&fakestate);
code = afs_CheckCode(code, &treq, 27);
done2:
#include <afsconfig.h>
#include "afs/param.h"
-
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* statistics */
#include "afs/afs_osidnlc.h"
#include "afs/afs_dynroot.h"
-
-extern struct DirEntry *afs_dir_GetBlob();
extern struct vcache *afs_globalVp;
-
afs_int32 afs_bkvolpref = 0;
afs_int32 afs_bulkStatsDone;
static int bulkStatCounter = 0; /* counter for bulk stat seq. numbers */
afs_int32 retry; /* handle low-level SGI MP race conditions */
long volStates; /* flags from vol structure */
struct volume *volp = 0; /* volume ptr */
- struct VenusFid dotdot = {0, 0, 0};
+ struct VenusFid dotdot = {0, {0, 0, 0}};
int flagIndex = 0; /* First file with bulk fetch flag set */
int inlinebulk = 0; /* Did we use InlineBulk RPC or not? */
XSTATS_DECLS;
afs_AddMarinerName(aname, tvc);
#if defined(UKERNEL) && defined(AFS_WEB_ENHANCEMENTS)
- if (!(flags & AFS_LOOKUP_NOEVAL))
+ if (!(flags & AFS_LOOKUP_NOEVAL)) {
/* Here we don't enter the name into the DNLC because we want the
- * evaluated mount dir to be there (the vcache for the mounted volume)
- * rather than the vc of the mount point itself. we can still find the
- * mount point's vc in the vcache by its fid. */
+ * evaluated mount dir to be there (the vcache for the mounted
+ * volume) rather than the vc of the mount point itself. We can
+ * still find the mount point's vc in the vcache by its fid. */
#endif /* UKERNEL && AFS_WEB_ENHANCEMENTS */
if (!hit && force_eval) {
osi_dnlc_enter(adp, aname, tvc, &versionNo);
return 0; /* can't have been any errors if hit and !code */
#endif
}
+#if defined(UKERNEL) && defined(AFS_WEB_ENHANCEMENTS)
+ }
+#endif
}
if (bulkcode)
code = bulkcode;
if ((afs_preCache != 0) && (writing == 0) && (vType(tvc) != VDIR) &&
(!afs_BBusy())) {
register struct dcache *tdc;
- afs_size_t offset, len, totallen = 0;
+ afs_size_t offset, len;
tdc = afs_GetDCache(tvc, 0, &treq, &offset, &len, 1);
if (!code) {
struct VenusFid *oldmvid = NULL;
if (tvc->mvid)
- oldmvid = (char *)tvc->mvid;
+ oldmvid = tvc->mvid;
tvc->mvid = (struct VenusFid *)unlname;
if (oldmvid)
osi_FreeSmallSpace(oldmvid);
{
register afs_int32 code;
struct uio tuio;
- struct uio *tuiop = &tuio;
struct iovec tiovec[1];
register struct vcache *tvc = VTOAFS(abp->b_vp);
register afs_int32 len = abp->b_bcount;
}
#endif
-int SRXAFSCB_GetDE(a_call, a_index, addr, inode, flags, time, fileName)
- struct rx_call *a_call;
- afs_int32 a_index;
- afs_int32 *addr;
- afs_int32 *inode;
- afs_int32 *flags;
- afs_int32 *time;
- char ** fileName;
+int SRXAFSCB_GetDE(struct rx_call *a_call, afs_int32 a_index, afs_int32 *addr,
+ afs_int32 *inode, afs_int32 *flags, afs_int32 *time,
+ char ** fileName)
{ /*SRXAFSCB_GetDE*/
int code = 0; /*Return code*/
#if 0 && defined(AFS_LINUX24_ENV)
tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
if (tc) {
- afs_int32 length_hi, length, bytes;
+#ifdef AFS_64BIT_CLIENT
+ afs_int32 length_hi;
+#endif
+ afs_int32 length, bytes;
#ifndef AFS_NOSTATS
numFetchLoops++;
if (fromReplica)
struct osi_file *tfile_src, *tfile_dst;
struct VenusFid shadow_fid;
char *data;
- int lock_held = 0;
/* Is this a dir? */
if (vType(avc) != VDIR)
afs_int32 afs_ConflictPolicy = SERVER_WINS;
-static void afs_DisconResetVCache(struct vcache *, struct AFS_UCRED *);
static void afs_DisconDiscardAllShadows(int, struct AFS_UCRED *);
void afs_DbgListDirEntries(struct VenusFid *afid);
struct afs_conn *tc;
afs_int32 hash, new_hash, index;
afs_size_t tlen;
- int code, op;
+ int code, op = 0;
XSTATS_DECLS;
tname = afs_osi_Alloc(AFSNAMEMAX);
struct AFSCallBack callback;
struct AFSVolSync tsync;
int code = 0;
- int ucode;
afs_int32 start = 0;
XSTATS_DECLS;
/*AFS_STATCNT(afs_ResyncDisconFiles);*/
*
* \note Call with afs_DDirtyVCListLock read locked.
*/
-void afs_DbgDisconFiles()
+void afs_DbgDisconFiles(void)
{
struct vcache *tvc;
struct afs_q *q;
}
-struct afs_icl_log *afs_icl_FindLog();
-struct afs_icl_set *afs_icl_FindSet();
+struct afs_icl_log *afs_icl_FindLog(char *);
+struct afs_icl_set *afs_icl_FindSet(char *);
int
* and kernel space. Call these to avoid taking page faults while
* holding the global lock.
*/
-#ifdef CAST_USER_ADDR_T
+#if defined(CAST_USER_ADDR_T) && !defined(UKERNEL)
#define __U(X) CAST_USER_ADDR_T((X))
#else
#define __U(X) (X)
#ifndef AFS_LINUX26_ONEGROUP_ENV
int
-afs_getpag_val()
+afs_getpag_val(void)
{
int pagvalue;
struct AFS_UCRED *credp = u.u_cred;
int
afs_InitReq(register struct vrequest *av, struct AFS_UCRED *acred)
{
+#ifdef AFS_LINUX26_ENV
int code;
+#endif
int i = 0;
AFS_STATCNT(afs_InitReq);
#else
pag = (afs_int32) afs_get_pag_from_groups(g0, g1);
#endif
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DUX40_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_XBSD_ENV)
out:
+#endif
#if defined(AFS_LINUX26_ENV) && defined(LINUX_KEYRING_SUPPORT)
if (pag == NOPAG && cred->cr_rgid != NFSXLATOR_CRED) {
struct key *key;
PGetPAG, /* 13 */
};
-static int (*(OpioctlSw[])) () = {
+static pioctlFunction OpioctlSw[] = {
PBogus, /* 0 */
PNFSNukeCreds, /* 1 -- nuke all creds for NFS client */
#if defined(AFS_CACHE_BYPASS)
#endif /* AFS_SUN5_ENV */
#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
return (code);
+#else
+ return 0;
#endif
}
#endif /* AFS_SGI_ENV */
#ifdef AFS_NEED_CLIENTCONTEXT
struct AFS_UCRED *tmpcred = NULL;
#endif
+#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)
struct AFS_UCRED *foreigncreds = NULL;
+#endif
register afs_int32 code = 0;
struct vnode *vp = NULL;
#ifdef AFS_AIX41_ENV
DECL_PIOCTL(PNFSNukeCreds)
{
- afs_uint32 addr, code;
+ afs_uint32 addr;
register afs_int32 i;
register struct unixuser *tu;
/* ARCH/osi_groups.c */
-#if defined AFS_XBSD_ENV
-#if !defined(AFS_DFBSD_ENV) || !defined(UKERNEL)
+#if defined(UKERNEL)
+extern int usr_setpag(struct usr_ucred **cred, afs_uint32 pagvalue,
+ afs_uint32 * newpag, int change_parent);
+#else
+# if defined AFS_XBSD_ENV
+# if !defined(AFS_DFBSD_ENV)
extern int setpag(struct proc *proc, struct ucred **cred, afs_uint32 pagvalue,
afs_uint32 * newpag, int change_parent);
-#endif
+# endif
+# endif
#endif
extern void vcache2fakeinode(struct vcache *rootvp, struct vcache *mpvp);
#endif
+#ifdef UKERNEL
+extern int afs_mount(struct vfs *path, char *data, struct vfs *afsp);
+extern int afs_root(OSI_VFS_DECL(afsp), struct vnode **avpp);
+extern int afs_unmount(struct vfs *afsp);
+#endif
+
/* afs_pag_call.c */
extern afs_int32 afs_nfs_server_addr;
extern void afspag_Init(afs_int32 nfs_server_addr);
extern void osi_ReleaseVM(struct vcache *avc, int len,
struct usr_ucred *credp);
extern int osi_GetTime(struct timeval *tv);
-#endif
-
-
+extern int iodone(struct usr_buf *bp);
+extern int usr_ioctl(void);
+extern int lookupname(char *fnamep, int segflg, int followlink,
+ struct usr_vnode **compvpp);
+extern int usr_uiomove(char *kbuf, int n, int rw, struct usr_uio *uio);
+extern int afs_osi_VOP_RDWR(struct usr_vnode *vnodeP, struct usr_uio *uioP,
+ int rw, int flags, struct usr_ucred *credP);
+#endif
/* afs_user.c */
extern afs_rwlock_t afs_xuser;
do {
tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
if (tc) {
+#ifdef AFS_64BIT_CLIENT
retry:
+#endif
RX_AFS_GUNLOCK();
tcall = rx_NewCall(tc->id);
RX_AFS_GLOCK();
stored = 0;
tc = afs_Conn(&avc->f.fid, areq, 0);
if (tc) {
+#ifdef AFS_64BIT_CLIENT
restart:
+#endif
RX_AFS_GUNLOCK();
tcall = rx_NewCall(tc->id);
#ifdef AFS_64BIT_CLIENT
void
-ForceAllNewConnections()
+ForceAllNewConnections(void)
{
int srvAddrCount;
struct srvAddr **addrs;
}
}
-void afs_RemoveAllConns()
+void afs_RemoveAllConns(void)
{
int i;
struct server *ts, *nts;
}
-void afs_MarkAllServersUp()
+void afs_MarkAllServersUp(void)
{
int i;
struct server *ts;
ReleaseWriteLock(&afs_xserver);
}
-void shutdown_server()
+void shutdown_server(void)
{
int i;
/* eparm is also used by AFSCALL_CALL in afsd.c */
#else
#if defined(UKERNEL)
+int
Afs_syscall()
{
register struct a {
/* Disk backed vcache definitions
* Both protected by xvcache */
+#ifdef AFS_DISCON_ENV
static int afs_nextVcacheSlot = 0;
static struct afs_slotlist *afs_freeSlotList = NULL;
+#endif
/* Forward declarations */
static afs_int32 afs_QueueVCB(struct vcache *avc);
shutdown_vcache(void)
{
int i;
- struct afs_cbr *tsp, *nsp;
+ struct afs_cbr *tsp;
/*
- * XXX We may potentially miss some of the vcaches because if when there're no
- * free vcache entries and all the vcache entries are active ones then we allocate
- * an additional one - admittedly we almost never had that occur.
+ * XXX We may potentially miss some of the vcaches because if when
+ * there are no free vcache entries and all the vcache entries are active
+ * ones then we allocate an additional one - admittedly we almost never
+ * had that occur.
*/
{
QInit(&afs_vhashTV[i]);
}
-void afs_DisconGiveUpCallbacks() {
+void afs_DisconGiveUpCallbacks(void) {
int i;
struct vcache *tvc;
int nq=0;
* disconnected mode to tidy up during reconnection
*
*/
-void afs_ClearAllStatdFlag() {
+void afs_ClearAllStatdFlag(void) {
int i;
struct vcache *tvc;
&& ts->addr) {
/* uuid, uniquifier, and portal are the same */
} else {
- afs_uint32 *addrp, nentries, code, unique;
+ afs_uint32 *addrp, code;
+ afs_int32 nentries, unique;
bulkaddrs addrs;
ListAddrByAttributes attrs;
afsUUID uuid;
int
ka_CellConfig(const char *dir)
{
- int code;
#ifdef UKERNEL
conf = afs_cdir;
strcpy(cell_name, afs_LclCellName);
return 0;
#else /* UKERNEL */
+ int code;
+
LOCK_GLOBAL_MUTEX;
if (conf)
afsconf_Close(conf);
char *
ka_LocalCell(void)
{
+#ifndef UKERNEL
int code = 0;
+#endif
LOCK_GLOBAL_MUTEX;
if (conf) {
struct usr_ifnet *usr_ifnet = NULL;
struct usr_in_ifaddr *usr_in_ifaddr = NULL;
-void rxk_InitializeSocket();
+void rxk_InitializeSocket(void);
void
afs_rxevent_daemon(void)
void
rxk_InitializeSocket(void)
{
- int rc, sock, i;
+ int rc, sock;
#ifdef AFS_USR_AIX_ENV
unsigned long len, optval, optval0, optlen;
#else /* AFS_USR_AIX_ENV */
{
int rc;
int i;
- unsigned long tmp;
struct usr_socket *usockp = (struct usr_socket *)sockp;
struct msghdr msg;
struct iovec tmpiov[64];
rx_getAllAddrMaskMtu(afs_uint32 addrBuffer[], afs_uint32 maskBuffer[],
afs_uint32 mtuBuffer[], int maxSize)
{
- int s;
- int i, len, count = 0;
+ int i, count = 0;
+#if defined(AFS_USERSPACE_IP_ADDR)
+ int s, len;
struct ifconf ifc;
struct ifreq ifs[NIFS], *ifr;
struct sockaddr_in *a;
+#endif
+
#if defined(AFS_AIX41_ENV) || defined(AFS_USR_AIX_ENV)
char *cp, *cplim; /* used only for AIX 41 */
#endif
rxi_InitPeerParams(struct rx_peer *pp)
{
u_short rxmtu;
- afs_int32 i, mtu;
#ifdef ADAPT_MTU
+ afs_int32 mtu;
#ifndef AFS_SUN5_ENV
#ifdef AFS_USERSPACE_IP_ADDR
+ afs_int32 i;
+
i = rxi_Findcbi(pp->host);
if (i == -1) {
pp->timeout.sec = 3;
git://git.openafs.org / openafs.git / commitdiff