+
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
#include <afsconfig.h>
#include "afs/param.h"
-RCSID
- ("$Header$");
-
-
#ifdef UKERNEL
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include <net/if.h>
+
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs_usrops.h"
#include "afs/afs_stats.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 usr_vnode *afs_FileTable[MAX_OSI_FILES];
int afs_FileFlags[MAX_OSI_FILES];
-int afs_FileOffsets[MAX_OSI_FILES];
+off_t afs_FileOffsets[MAX_OSI_FILES];
#define MAX_CACHE_LOOPS 4
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;
usr_key_t afs_global_u_key;
-struct usr_proc *afs_global_procp;
-struct usr_ucred *afs_global_ucredp;
+struct usr_proc *afs_global_procp = NULL;
+struct usr_ucred *afs_global_ucredp = NULL;
struct usr_sysent usr_sysent[200];
#ifdef AFS_USR_OSF_ENV
#endif /* !NETSCAPE_NSAPI */
int call_syscall(long, long, long, long, long, long);
+int fork_syscall(long, long, long, long, long, long);
/*
ufs_brelse(struct usr_vnode *vp, struct usr_buf *bp)
{
usr_assert(0);
+ return 0;
}
/*
iodone(struct usr_buf *bp)
{
usr_assert(0);
+ return 0;
}
struct usr_file *
getf(int fd)
{
usr_assert(0);
+ return 0;
}
/*
usr_flock(void)
{
usr_assert(0);
+ return 0;
}
/*
usr_ioctl(void)
{
usr_assert(0);
+ return 0;
}
/*
* We do not support the inode related system calls
*/
int
-afs_syscall_icreate(void)
+afs_syscall_icreate(long a, long b, long c, long d, long e, long f)
{
usr_assert(0);
+ return 0;
}
int
-afs_syscall_iincdec(void)
+afs_syscall_iincdec(int dev, int inode, int inode_p1, int amount)
{
usr_assert(0);
+ return 0;
}
int
-afs_syscall_iopen(void)
+afs_syscall_iopen(int dev, int inode, int usrmod)
{
usr_assert(0);
+ return 0;
}
int
afs_syscall_ireadwrite(void)
{
usr_assert(0);
+ return 0;
}
/*
vno_close(void)
{
usr_assert(0);
+ return 0;
}
int
vno_ioctl(void)
{
usr_assert(0);
+ return 0;
}
int
vno_rw(void)
{
usr_assert(0);
+ return 0;
}
int
vno_select(void)
{
usr_assert(0);
+ return 0;
}
/*
if (credp->cr_ref == 0) {
afs_osi_Free((char *)credp, sizeof(struct usr_ucred));
}
+ return 0;
}
int
usr_crhold(struct usr_ucred *credp)
{
credp->cr_ref++;
+ return 0;
}
void
waitp = waitp->next;
}
usr_mutex_unlock(&osi_waitq_lock);
+ return 0;
+}
+
+int
+afs_osi_TimedSleep(void *event, afs_int32 ams, int aintok)
+{
+ return afs_osi_Wait(ams, event, aintok);
}
int
waitp = waitp->timedNext;
}
usr_mutex_unlock(&osi_waitq_lock);
+ return 0;
}
/*
* open a file given its i-node number
*/
void *
-osi_UFSOpen(afs_int32 ino)
+osi_UFSOpen(afs_dcache_id_t *ino)
{
int rc;
struct osi_file *fp;
AFS_ASSERT_GLOCK();
- if (ino > n_osi_files) {
- u.u_error = ENOENT;
+ if (ino->ufs > n_osi_files) {
+ get_user_struct()->u_error = ENOENT;
return NULL;
}
AFS_GUNLOCK();
fp = (struct osi_file *)afs_osi_Alloc(sizeof(struct osi_file));
usr_assert(fp != NULL);
- fp->fd = open(osi_file_table[ino - 1].name, O_RDWR | O_CREAT, 0);
+ fp->fd = open(osi_file_table[ino->ufs - 1].name, O_RDWR | O_CREAT, 0);
if (fp->fd < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
afs_osi_Free((char *)fp, sizeof(struct osi_file));
AFS_GLOCK();
return NULL;
}
rc = fstat(fp->fd, &st);
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
afs_osi_Free((void *)fp, sizeof(struct osi_file));
AFS_GLOCK();
return NULL;
}
fp->size = st.st_size;
fp->offset = 0;
- fp->inum = ino;
fp->vnode = (struct usr_vnode *)fp;
AFS_GLOCK();
AFS_GUNLOCK();
rc = close(fp->fd);
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
afs_osi_Free((void *)fp, sizeof(struct osi_file));
AFS_GLOCK();
return -1;
AFS_GUNLOCK();
rc = ftruncate(fp->fd, len);
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
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();
rc = lseek(fp->fd, fp->offset, SEEK_SET);
}
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
fp->offset = rc;
ret = read(fp->fd, buf, len);
if (ret < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
fp->offset += ret;
rc = fstat(fp->fd, &st);
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
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();
rc = lseek(fp->fd, fp->offset, SEEK_SET);
}
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
fp->offset = rc;
ret = write(fp->fd, buf, len);
if (ret < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
fp->offset += ret;
rc = fstat(fp->fd, &st);
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
AFS_GUNLOCK();
rc = fstat(fp->fd, &st);
if (rc < 0) {
- u.u_error = errno;
+ get_user_struct()->u_error = errno;
AFS_GLOCK();
return -1;
}
uioP->uio_iov[0].iov_len);
}
if (rc < 0) {
- return u.u_error;
+ return get_user_struct()->u_error;
}
uioP->uio_resid -= rc;
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)
{
return;
}
+void
+afs_osi_Visible(void)
+{
+ return;
+}
+
int
osi_GetTime(struct timeval *tv)
{
}
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);
}
void
-osi_FlushPages(register struct vcache *avc, struct AFS_UCRED *credp)
+osi_FlushPages(register struct vcache *avc, afs_ucred_t *credp)
{
ObtainSharedLock(&avc->lock, 555);
- if ((hcmp((avc->m.DataVersion), (avc->mapDV)) <= 0)
+ if ((hcmp((avc->f.m.DataVersion), (avc->mapDV)) <= 0)
|| ((avc->execsOrWriters > 0) && afs_DirtyPages(avc))) {
ReleaseSharedLock(&avc->lock);
return;
}
UpgradeSToWLock(&avc->lock, 565);
- hset(avc->mapDV, avc->m.DataVersion);
+ hset(avc->mapDV, avc->f.m.DataVersion);
ReleaseWriteLock(&avc->lock);
return;
}
void
osi_FlushText_really(register struct vcache *vp)
{
- if (hcmp(vp->m.DataVersion, vp->flushDV) > 0) {
- hset(vp->flushDV, vp->m.DataVersion);
+ if (hcmp(vp->f.m.DataVersion, vp->flushDV) > 0) {
+ hset(vp->flushDV, vp->f.m.DataVersion);
}
return;
}
osi_Init(void)
{
int i;
- int rc;
- usr_thread_t tid;
/*
* Allocate the table used to implement psuedo-inodes.
for (currp = readdir(cdirp); currp; currp = readdir(cdirp)) {
if (afsd_debug) {
printf("%s: Current directory entry:\n", rn);
+#if defined(AFS_SGI62_ENV) || defined(AFS_USR_DARWIN100_ENV)
+ printf("\tinode=%" AFS_INT64_FMT ", reclen=%d, name='%s'\n",
+ currp->d_ino, currp->d_reclen, currp->d_name);
+#elif defined(AFS_USR_DFBSD_ENV)
+ printf("\tinode=%d, name='%s'\n", currp->d_ino,
+ currp->d_name);
+#else
printf("\tinode=%d, reclen=%d, name='%s'\n", currp->d_ino,
currp->d_reclen, currp->d_name);
+#endif
}
/*
return (0);
}
-static
-ConfigCell(register struct afsconf_cell *aci, char *arock,
+static int
+ConfigCell(register struct afsconf_cell *aci, void *arock,
struct afsconf_dir *adir)
{
register int isHomeCell;
}
static int
-ConfigCellAlias(aca, arock, adir)
- struct afsconf_cellalias *aca;
- char *arock;
- struct afsconf_dir *adir;
+ConfigCellAlias(struct afsconf_cellalias *aca, void *arock, struct afsconf_dir *adir)
{
call_syscall(AFSOP_ADDCELLALIAS, (long)aca->aliasName,
(long)aca->realName, 0, 0, 0);
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;
afs_osi_Alloc(sizeof(struct usr_ucred));
usr_assert(afs_global_ucredp != NULL);
afs_global_ucredp->cr_ref = 1;
- afs_global_ucredp->cr_uid = geteuid();
- afs_global_ucredp->cr_gid = getegid();
- afs_global_ucredp->cr_ruid = getuid();
- afs_global_ucredp->cr_rgid = getgid();
- afs_global_ucredp->cr_suid = afs_global_ucredp->cr_ruid;
- afs_global_ucredp->cr_sgid = afs_global_ucredp->cr_rgid;
+ afs_set_cr_uid(afs_global_ucredp, geteuid());
+ afs_set_cr_gid(afs_global_ucredp, getegid());
+ afs_set_cr_ruid(afs_global_ucredp, getuid());
+ afs_set_cr_rgid(afs_global_ucredp, getgid());
+ afs_global_ucredp->cr_suid = afs_cr_ruid(afs_global_ucredp);
+ afs_global_ucredp->cr_sgid = afs_cr_rgid(afs_global_ucredp);
st = getgroups(NGROUPS, &afs_global_ucredp->cr_groups[0]);
usr_assert(st >= 0);
afs_global_ucredp->cr_ngroups = (unsigned long)st;
afs_global_procp = (struct usr_proc *)
afs_osi_Alloc(sizeof(struct usr_proc));
usr_assert(afs_global_procp != NULL);
- afs_global_procp->p_pid = getpid();
+ afs_global_procp->p_pid = osi_getpid();
afs_global_procp->p_ppid = (pid_t) 1;
afs_global_procp->p_ucred = afs_global_ucredp;
cacheStatEntries = cacheStatEntriesParam;
}
strcpy(cacheBaseDir, cacheBaseDirParam);
- if (nDaemons != 0) {
+ if (nDaemonsParam != 0) {
nDaemons = nDaemonsParam;
} else {
nDaemons = 3;
printf("%s: My home cell is '%s'\n", rn, afs_LclCellName);
}
- /*
- * Set the primary cell name.
- */
- call_syscall(AFSOP_SET_THISCELL, (long)afs_LclCellName, 0, 0, 0, 0);
-
if ((logfd = fopen(fullpn_AFSLogFile, "r+")) == 0) {
if (afsd_verbose)
printf("%s: Creating '%s'\n", rn, fullpn_AFSLogFile);
}
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.
sprintf(fullpn_VFile, "%s/V", cacheBaseDir);
vFileNumber = fullpn_VFile + strlen(fullpn_VFile);
- /*
- * Start the RX listener.
- */
- if (afsd_debug)
- printf("%s: Calling AFSOP_RXLISTENER_DAEMON\n", rn);
- fork_syscall(AFSCALL_CALL, AFSOP_RXLISTENER_DAEMON, FALSE, FALSE, FALSE);
-
- /*
- * Start the RX event handler.
- */
- if (afsd_debug)
- printf("%s: Calling AFSOP_RXEVENT_DAEMON\n", rn);
- fork_syscall(AFSCALL_CALL, AFSOP_RXEVENT_DAEMON, FALSE);
-
- /*
- * Set up all the kernel processes needed for AFS.
- */
-
/* initialize AFS callback interface */
{
/* parse multihomed address files */
}
}
+ /*
+ * Start the RX listener.
+ */
+ if (afsd_debug)
+ printf("%s: Calling AFSOP_RXLISTENER_DAEMON\n", rn);
+ fork_syscall(AFSCALL_CALL, AFSOP_RXLISTENER_DAEMON, FALSE, FALSE, FALSE, 0);
+
if (afsd_verbose)
printf("%s: Forking rx callback listener.\n", rn);
/* Child */
if (preallocs < cacheStatEntries + 50)
preallocs = cacheStatEntries + 50;
- fork_syscall(AFSCALL_CALL, AFSOP_START_RXCALLBACK, preallocs);
+ fork_syscall(AFSCALL_CALL, AFSOP_START_RXCALLBACK, preallocs, 0, 0, 0);
+
+ /*
+ * Start the RX event handler.
+ */
+ if (afsd_debug)
+ printf("%s: Calling AFSOP_RXEVENT_DAEMON\n", rn);
+ fork_syscall(AFSCALL_CALL, AFSOP_RXEVENT_DAEMON, FALSE, 0, 0, 0);
+
+ /*
+ * Set up all the kernel processes needed for AFS.
+ */
if (afsd_verbose)
printf("%s: Initializing AFS daemon.\n", rn);
afsconf_CellApply(afs_cdir, ConfigCell, NULL);
afsconf_CellAliasApply(afs_cdir, ConfigCellAlias, NULL);
+ /*
+ * Set the primary cell name.
+ */
+ call_syscall(AFSCALL_CALL, AFSOP_SET_THISCELL, (long)afs_LclCellName, 0, 0, 0);
+
if (afsd_verbose)
printf("%s: Forking AFS daemon.\n", rn);
- fork_syscall(AFSCALL_CALL, AFSOP_START_AFS);
+ fork_syscall(AFSCALL_CALL, AFSOP_START_AFS, 0, 0, 0, 0);
if (afsd_verbose)
printf("%s: Forking check server daemon.\n", rn);
- fork_syscall(AFSCALL_CALL, AFSOP_START_CS);
+ fork_syscall(AFSCALL_CALL, AFSOP_START_CS, 0, 0, 0, 0);
if (afsd_verbose)
printf("%s: Forking %d background daemons.\n", rn, nDaemons);
for (i = 0; i < nDaemons; i++) {
- fork_syscall(AFSCALL_CALL, AFSOP_START_BKG);
+ fork_syscall(AFSCALL_CALL, AFSOP_START_BKG, 0, 0, 0, 0);
}
if (afsd_verbose)
(long)pathname_for_V[currVFile], 0, 0, 0);
}
/*end for */
-#ifndef NETSCAPE_NSAPI
+/*#ifndef NETSCAPE_NSAPI*/
+#if 0
+/* this breaks solaris if the kernel-mode client has never been installed,
+ * and it doesn't seem to work now anyway, so just disable it */
+
/*
* Copy our tokens from the kernel to the user space client
*/
rc = lpioctl(0, _VICEIOCTL(8), &iob, 0);
#endif
if (rc < 0) {
- usr_assert(errno == EDOM || errno == ENOSYS);
+ usr_assert(errno == EDOM || errno == ENOSYS || errno == ERANGE);
break;
}
if (afsd_verbose)
printf("%s: Forking trunc-cache daemon.\n", rn);
- fork_syscall(AFSCALL_CALL, AFSOP_START_TRUNCDAEMON);
+ fork_syscall(AFSCALL_CALL, AFSOP_START_TRUNCDAEMON, 0, 0, 0, 0);
/*
* Mount the AFS filesystem
return;
}
+int
+uafs_statvfs(struct statvfs *buf)
+{
+ int rc;
+
+ AFS_GLOCK();
+
+ rc = afs_statvfs(&afs_RootVfs, buf);
+
+ AFS_GUNLOCK();
+
+ if (rc) {
+ errno = rc;
+ return -1;
+ }
+
+ return 0;
+}
+
void
uafs_Shutdown(void)
{
/*
* AFS daemons run authenticated
*/
- u.u_viceid = getuid();
- crp = u.u_cred;
- crp->cr_uid = getuid();
- crp->cr_ruid = getuid();
+ get_user_struct()->u_viceid = getuid();
+ crp = get_user_struct()->u_cred;
+ afs_set_cr_uid(crp, getuid());
+ afs_set_cr_ruid(crp, getuid());
crp->cr_suid = getuid();
crp->cr_groups[0] = getgid();
crp->cr_ngroups = 1;
sysArgsP->param2, sysArgsP->param3, sysArgsP->param4);
afs_osi_Free(argp, -1);
+ return 0;
}
-fork_syscall(syscall, afscall, param1, param2, param3, param4)
- long syscall, afscall, param1, param2, param3, param4;
+int
+fork_syscall(long syscall, long afscall, long param1, long param2,
+ long param3, long param4)
{
usr_thread_t tid;
struct syscallThreadArgs *sysArgsP;
usr_thread_create(&tid, syscallThread, sysArgsP);
usr_thread_detach(tid);
+ return 0;
}
-call_syscall(syscall, afscall, param1, param2, param3, param4)
- long syscall, afscall, param1, param2, param3, param4;
+int
+call_syscall(long syscall, long afscall, long param1, long param2,
+ long param3, long param4)
{
int code = 0;
struct a {
a.parm3 = param3;
a.parm4 = param4;
- u.u_error = 0;
- u.u_ap = (char *)&a;
+ get_user_struct()->u_error = 0;
+ get_user_struct()->u_ap = (char *)&a;
code = Afs_syscall();
return code;
iob.in_size = tlen;
iob.out = &outbuf[0];
iob.out_size = sizeof(outbuf);
+
rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(3), (long)&iob, 0, 0);
if (rc != 0) {
errno = rc;
uafs_LookupName(char *path, struct usr_vnode *parentVp,
struct usr_vnode **vpp, int follow, int no_eval_mtpt)
{
- int code;
+ int code = 0;
int linkCount;
struct usr_vnode *vp;
struct usr_vnode *nextVp;
struct usr_vnode *linkVp;
+ struct vcache *nextVc;
char *tmpPath;
char *pathP;
- char *nextPathP;
+ char *nextPathP = NULL;
AFS_ASSERT_GLOCK();
/*
* We need execute permission to search a directory
*/
- code = afs_access(VTOAFS(vp), VEXEC, u.u_cred);
+ code = afs_access(VTOAFS(vp), VEXEC, get_user_struct()->u_cred);
if (code != 0) {
VN_RELE(vp);
afs_osi_Free(tmpPath, strlen(path) + 1);
* 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, get_user_struct()->u_cred, 0);
else
code =
- afs_lookup(vp, pathP, &nextVp, u.u_cred,
+ afs_lookup(VTOAFS(vp), pathP, &nextVc, get_user_struct()->u_cred,
AFS_LOOKUP_NOEVAL);
#else
- code = afs_lookup(vp, pathP, &nextVp, u.u_cred, 0);
+ code = afs_lookup(VTOAFS(vp), pathP, &nextVc, get_user_struct()->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, get_user_struct()->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)) {
usr_vattr_null(&attrs);
attrs.va_type = VREG;
attrs.va_mode = mode;
- attrs.va_uid = u.u_cred->cr_uid;
- attrs.va_gid = u.u_cred->cr_gid;
+ attrs.va_uid = afs_cr_uid(get_user_struct()->u_cred);
+ attrs.va_gid = afs_cr_gid(get_user_struct()->u_cred);
dirP = NULL;
- code = afs_mkdir(parentP, nameP, &attrs, &dirP, u.u_cred);
+ code = afs_mkdir(VTOAFS(parentP), nameP, &attrs, &dirP, get_user_struct()->u_cred);
VN_RELE(parentP);
if (code != 0) {
errno = code;
return -1;
}
- VN_RELE(dirP);
+ VN_RELE(AFSTOV(dirP));
return 0;
}
usr_vattr_null(&attrs);
attrs.va_type = VREG;
attrs.va_mode = mode;
- attrs.va_uid = u.u_cred->cr_uid;
- attrs.va_gid = u.u_cred->cr_gid;
+ attrs.va_uid = afs_cr_uid(get_user_struct()->u_cred);
+ attrs.va_gid = afs_cr_gid(get_user_struct()->u_cred);
if (flags & O_TRUNC) {
attrs.va_size = 0;
}
code =
afs_create(VTOAFS(dirP), nameP, &attrs,
(flags & O_EXCL) ? usr_EXCL : usr_NONEXCL, mode,
- &vc, u.u_cred);
+ &vc, get_user_struct()->u_cred);
VN_RELE(dirP);
if (code != 0) {
errno = code;
return -1;
}
+ fileP = AFSTOV(vc);
} else {
fileP = NULL;
code = uafs_LookupName(nameP, dirP, &fileP, 1, 0);
}
if (!fileMode)
fileMode = VREAD; /* since O_RDONLY is 0 */
- code = afs_access(VTOAFS(fileP), fileMode, u.u_cred);
+ code = afs_access(VTOAFS(fileP), fileMode, get_user_struct()->u_cred);
if (code != 0) {
VN_RELE(fileP);
errno = code;
/*
* Get the file attributes, all we need is the size
*/
- code = afs_getattr(VTOAFS(fileP), &attrs, u.u_cred);
+ code = afs_getattr(VTOAFS(fileP), &attrs, get_user_struct()->u_cred);
if (code != 0) {
VN_RELE(fileP);
errno = code;
*/
if ((flags & O_TRUNC) && (attrs.va_size != 0)) {
usr_vattr_null(&attrs);
+ attrs.va_mask = ATTR_SIZE;
attrs.va_size = 0;
- code = afs_setattr(VTOAFS(fileP), &attrs, u.u_cred);
+ code = afs_setattr(VTOAFS(fileP), &attrs, get_user_struct()->u_cred);
if (code != 0) {
VN_RELE(fileP);
errno = code;
/*
* do the open
*/
- code = afs_open(&vc, openFlags, u.u_cred);
+ code = afs_open(&vc, openFlags, get_user_struct()->u_cred);
if (code != 0) {
VN_RELE(fileP);
errno = code;
{
int retval;
AFS_GLOCK();
- retval = uafs_write_r(fd, buf, len);
+ retval = uafs_pwrite_r(fd, buf, len, afs_FileOffsets[fd]);
+ AFS_GUNLOCK();
+ return retval;
+}
+
+int
+uafs_pwrite(int fd, char *buf, int len, off_t offset)
+{
+ int retval;
+ AFS_GLOCK();
+ retval = uafs_pwrite_r(fd, buf, len, offset);
AFS_GUNLOCK();
return retval;
}
int
-uafs_write_r(int fd, char *buf, int len)
+uafs_pwrite_r(int fd, char *buf, int len, off_t offset)
{
int code;
struct usr_uio uio;
iov[0].iov_len = len;
uio.uio_iov = &iov[0];
uio.uio_iovcnt = 1;
- uio.uio_offset = afs_FileOffsets[fd];
+ uio.uio_offset = offset;
uio.uio_segflg = 0;
uio.uio_fmode = FWRITE;
uio.uio_resid = len;
* do the write
*/
- code = afs_write(VTOAFS(fileP), &uio, afs_FileFlags[fd], u.u_cred, 0);
+ code = afs_write(VTOAFS(fileP), &uio, afs_FileFlags[fd], get_user_struct()->u_cred, 0);
if (code) {
errno = code;
return -1;
{
int retval;
AFS_GLOCK();
- retval = uafs_read_r(fd, buf, len);
+ retval = uafs_pread_r(fd, buf, len, afs_FileOffsets[fd]);
AFS_GUNLOCK();
return retval;
}
int
-uafs_read_r(int fd, char *buf, int len)
+uafs_pread(int fd, char *buf, int len, off_t offset)
+{
+ int retval;
+ AFS_GLOCK();
+ retval = uafs_pread_r(fd, buf, len, offset);
+ AFS_GUNLOCK();
+ return retval;
+}
+
+int
+uafs_pread_r(int fd, char *buf, int len, off_t offset)
{
int code;
struct usr_uio uio;
iov[0].iov_len = len;
uio.uio_iov = &iov[0];
uio.uio_iovcnt = 1;
- uio.uio_offset = afs_FileOffsets[fd];
+ uio.uio_offset = offset;
uio.uio_segflg = 0;
uio.uio_fmode = FREAD;
uio.uio_resid = len;
/*
* do the read
*/
- code = afs_read(VTOAFS(fileP), &uio, u.u_cred, 0, &bufP, 0);
+ code = afs_read(VTOAFS(fileP), &uio, get_user_struct()->u_cred, 0, &bufP, 0);
if (code) {
errno = code;
return -1;
/*
* Get the attributes
*/
- code = afs_getattr(VTOAFS(vp), &attrs, u.u_cred);
+ code = afs_getattr(VTOAFS(vp), &attrs, get_user_struct()->u_cred);
if (code != 0) {
return code;
}
return -1;
}
usr_vattr_null(&attrs);
+ attrs.va_mask = ATTR_MODE;
attrs.va_mode = mode;
- code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
+ code = afs_setattr(VTOAFS(vp), &attrs, get_user_struct()->u_cred);
VN_RELE(vp);
if (code != 0) {
errno = code;
return -1;
}
usr_vattr_null(&attrs);
+ attrs.va_mask = ATTR_MODE;
attrs.va_mode = mode;
- code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
+ code = afs_setattr(VTOAFS(vp), &attrs, get_user_struct()->u_cred);
if (code != 0) {
errno = code;
return -1;
return -1;
}
usr_vattr_null(&attrs);
+ attrs.va_mask = ATTR_SIZE;
attrs.va_size = length;
- code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
+ code = afs_setattr(VTOAFS(vp), &attrs, get_user_struct()->u_cred);
VN_RELE(vp);
if (code != 0) {
errno = code;
return -1;
}
usr_vattr_null(&attrs);
+ attrs.va_mask = ATTR_SIZE;
attrs.va_size = length;
- code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
+ code = afs_setattr(VTOAFS(vp), &attrs, get_user_struct()->u_cred);
if (code != 0) {
errno = code;
return -1;
newpos = offset;
break;
case SEEK_END:
- code = afs_getattr(VTOAFS(vp), &attrs, u.u_cred);
+ code = afs_getattr(VTOAFS(vp), &attrs, get_user_struct()->u_cred);
if (code != 0) {
errno = code;
return -1;
return -1;
}
- code = afs_fsync(fileP, u.u_cred);
+ code = afs_fsync(VTOAFS(fileP), get_user_struct()->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], get_user_struct()->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, get_user_struct()->u_cred);
VN_RELE(existP);
VN_RELE(dirP);
if (code != 0) {
usr_vattr_null(&attrs);
attrs.va_type = VLNK;
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);
+ attrs.va_uid = afs_cr_uid(get_user_struct()->u_cred);
+ attrs.va_gid = afs_cr_gid(get_user_struct()->u_cred);
+ code = afs_symlink(VTOAFS(dirP), nameP, &attrs, target, get_user_struct()->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, get_user_struct()->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, get_user_struct()->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, get_user_struct()->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, get_user_struct()->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, get_user_struct()->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;
struct usr_dirent *direntP;
struct min_direct *directP;
+ if (!dirp) {
+ errno = EBADF;
+ return NULL;
+ }
+
/*
* Make sure this is an open file
*/
/*
* read the next chunk from the directory
*/
- code = afs_readdir(vp, &uio, u.u_cred);
+ code = afs_readdir(VTOAFS(vp), &uio, get_user_struct()->u_cred);
if (code != 0) {
errno = code;
return NULL;
int fd;
int rc;
+ if (!dirp) {
+ errno = EBADF;
+ return -1;
+ }
+
fd = dirp->dd_fd;
afs_osi_Free((char *)dirp,
sizeof(usr_DIR) + USR_DIRSIZE + sizeof(struct usr_dirent));
return -1;
}
- *status = (afs_int32) iob.out;
+ *status = (intptr_t)iob.out;
return 0;
}
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, get_user_struct()->u_cred);
AFS_GUNLOCK();
return afs_rights;
git://git.openafs.org / openafs.git / blobdiff