/*!
* Print list of disconnected files.
*
* \note Call with afs_DDirtyVCListLock read locked.
*/
void
afs_DbgDisconFiles(void)
{
struct vcache *tvc;
struct afs_q *q;
int i = 0;
afs_warn("List of dirty files: \n");
ObtainReadLock(&afs_disconDirtyLock);
for (q = QPrev(&afs_disconDirty); q != &afs_disconDirty; q = QPrev(q)) {
tvc = QEntry(q, struct vcache, dirtyq);
afs_warn("Cell=%u Volume=%u VNode=%u Unique=%u\n",
tvc->f.fid.Cell,
tvc->f.fid.Fid.Volume,
tvc->f.fid.Fid.Vnode,
tvc->f.fid.Fid.Unique);
i++;
if (i >= 30)
osi_Panic("afs_DbgDisconFiles: loop in dirty list\n");
}
ReleaseReadLock(&afs_disconDirtyLock);
}
afs_int32
VnodeToSize(vnode_t * vp)
{
int code;
struct vattr vattr;
/*
* We lock xosi in osi_Stat, so we probably should
* lock it here too - RWH.
*/
ObtainWriteLock(&afs_xosi, 578);
vattr.va_mask = AT_SIZE;
AFS_GUNLOCK();
#ifdef AFS_SUN511_ENV
code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp, NULL);
#else
code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp);
#endif
AFS_GLOCK();
if (code) {
osi_Panic("VnodeToSize");
}
ReleaseWriteLock(&afs_xosi);
return (afs_int32) (vattr.va_size);
}
/* Generic write interface */
int
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
ssize_t resid;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
if (offset != -1)
afile->offset = offset;
AFS_GUNLOCK();
code =
gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
afile->offset, AFS_UIOSYS, 0, RLIM64_INFINITY, afs_osi_credp,
&resid);
AFS_GLOCK();
if (code == 0) {
code = asize - resid;
afile->offset += code;
} else {
if (code > 0) {
code = -code;
}
}
if (afile->proc) {
(*afile->proc) (afile, code);
}
return code;
}
/* Generic write interface */
int
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
long resid;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
if (offset != -1)
afile->offset = offset;
AFS_GUNLOCK();
code =
gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
afile->offset, AFS_UIOSYS, IO_UNIT, &resid);
AFS_GLOCK();
if (code == 0) {
code = asize - resid;
afile->offset += code;
} else {
if (code == ENOSPC)
afs_warnuser
("\n\n\n*** Cache partition is FULL - Decrease cachesize!!! ***\n\n");
setuerror(code);
if (code > 0) {
code = -code;
}
}
if (afile->proc) {
(*afile->proc) (afile, code);
}
return code;
}
static void
afs_evict_inode(struct inode *ip)
{
struct vcache *vcp = VTOAFS(ip);
if (vcp->vlruq.prev || vcp->vlruq.next)
osi_Panic("inode freed while on LRU");
if (vcp->hnext)
osi_Panic("inode freed while still hashed");
truncate_inode_pages(&ip->i_data, 0);
end_writeback(ip);
#if !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
afs_osi_Free(ip->u.generic_ip, sizeof(struct vcache));
#endif
}
int
osi_NetReceive(osi_socket asocket, struct sockaddr_in *addr,
struct iovec *dvec, int nvecs, int *alength)
{
struct uio u;
int i;
struct iovec iov[RX_MAXIOVECS];
struct sockaddr *sa = NULL;
int code;
int haveGlock = ISAFS_GLOCK();
/*AFS_STATCNT(osi_NetReceive); */
if (nvecs > RX_MAXIOVECS)
osi_Panic("osi_NetReceive: %d: Too many iovecs.\n", nvecs);
for (i = 0; i < nvecs; i++)
iov[i] = dvec[i];
u.uio_iov = &iov[0];
u.uio_iovcnt = nvecs;
u.uio_offset = 0;
u.uio_resid = *alength;
u.uio_segflg = UIO_SYSSPACE;
u.uio_rw = UIO_READ;
#ifdef AFS_FBSD50_ENV
u.uio_td = NULL;
#else
u.uio_procp = NULL;
#endif
if (haveGlock)
AFS_GUNLOCK();
code = soreceive(asocket, &sa, &u, NULL, NULL, NULL);
if (haveGlock)
AFS_GLOCK();
if (code) {
#if KNET_DEBUG
if (code == EINVAL)
Debugger("afs NetReceive busted");
else
printf("y");
#else
return code;
#endif
}
*alength -= u.uio_resid;
if (sa) {
if (sa->sa_family == AF_INET) {
if (addr)
*addr = *(struct sockaddr_in *)sa;
} else
printf("Unknown socket family %d in NetReceive\n", sa->sa_family);
FREE(sa, M_SONAME);
}
return code;
}
/* Generic read interface */
int
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
unsigned int resid;
afs_int32 code;
afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
* If the osi_file passed in is NULL, panic only if AFS is not shutting
* down. No point in crashing when we are already shutting down
*/
if (!afile) {
if (!afs_shuttingdown)
osi_Panic("osi_Read called with null param");
else
return -EIO;
}
if (offset != -1)
afile->offset = offset;
retry_IO:
/* Note the difference in the way the afile->offset is passed (see comments in gop_rdwr() in afs_aix_subr.c for comments) */
AFS_GUNLOCK();
#ifdef AFS_64BIT_KERNEL
code =
gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize,
&afile->offset, AFS_UIOSYS, NULL, &resid);
#else
code =
gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize,
(off_t) & afile->offset, AFS_UIOSYS, NULL, &resid);
#endif
AFS_GLOCK();
if (code == 0) {
code = asize - resid;
afile->offset += code;
osi_DisableAtimes(afile->vnode);
} else {
afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid,
ICL_TYPE_INT32, code);
/*
* To handle periodic low-level EFAULT failures that we've seen with the
* Weitek chip; in all observed failed cases a second read succeeded.
*/
if ((code == EFAULT) && (cnt1++ < 5)) {
afs_stats_cmperf.osiread_efaults++;
goto retry_IO;
}
setuerror(code);
if (code > 0) {
code = -code;
}
}
return code;
}
int
osi_NetSend(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
int nvecs, afs_int32 alength, int istack)
{
register afs_int32 code;
int i;
struct iovec iov[RX_MAXIOVECS];
struct uio u;
int haveGlock = ISAFS_GLOCK();
AFS_STATCNT(osi_NetSend);
if (nvecs > RX_MAXIOVECS)
osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
for (i = 0; i < nvecs; i++)
iov[i] = dvec[i];
u.uio_iov = &iov[0];
u.uio_iovcnt = nvecs;
u.uio_offset = 0;
u.uio_resid = alength;
u.uio_segflg = UIO_SYSSPACE;
u.uio_rw = UIO_WRITE;
#ifdef AFS_FBSD50_ENV
u.uio_td = NULL;
#else
u.uio_procp = NULL;
#endif
addr->sin_len = sizeof(struct sockaddr_in);
if (haveGlock)
AFS_GUNLOCK();
#if KNET_DEBUG
printf("+");
#endif
#ifdef AFS_FBSD50_ENV
code =
sosend(asocket, (struct sockaddr *)addr, &u, NULL, NULL, 0,
curthread);
#else
code =
sosend(asocket, (struct sockaddr *)addr, &u, NULL, NULL, 0, curproc);
#endif
#if KNET_DEBUG
if (code) {
if (code == EINVAL)
Debugger("afs NetSend busted");
else
printf("z");
}
#endif
if (haveGlock)
AFS_GLOCK();
return code;
}
int
osi_NetReceive(osi_socket asocket, struct sockaddr_in *addr,
struct iovec *dvec, int nvecs, int *alength)
{
struct uio u;
int i, code;
struct iovec iov[RX_MAXIOVECS];
struct mbuf *nam = NULL;
int haveGlock = ISAFS_GLOCK();
memset(&u, 0, sizeof(u));
memset(&iov, 0, sizeof(iov));
if (nvecs > RX_MAXIOVECS)
osi_Panic("osi_NetReceive: %d: too many iovecs\n", nvecs);
for (i = 0; i < nvecs; i++)
iov[i] = dvec[i];
u.uio_iov = &iov[0];
u.uio_iovcnt = nvecs;
u.uio_offset = 0;
u.uio_resid = *alength;
u.uio_segflg = UIO_SYSSPACE;
u.uio_rw = UIO_READ;
u.uio_procp = NULL;
if (haveGlock)
AFS_GUNLOCK();
code = soreceive(asocket, (addr ? &nam : NULL), &u, NULL, NULL, NULL
#if defined(AFS_OBSD45_ENV)
, 0
#endif
);
if (haveGlock)
AFS_GLOCK();
if (code) {
#ifdef RXKNET_DEBUG
printf("rx code %d termState %d\n", code, afs_termState);
#endif
while (afs_termState == AFSOP_STOP_RXEVENT)
afs_osi_Sleep(&afs_termState);
return code;
}
*alength -= u.uio_resid;
if (addr && nam) {
memcpy(addr, mtod(nam, caddr_t), nam->m_len);
m_freem(nam);
}
return code;
}
void
afs_mutex_exit(afs_kmutex_t * l)
{
if (l->owner != current->pid)
osi_Panic("mutex_exit: 0x%lx held by %d", (unsigned long)l, l->owner);
l->owner = 0;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
mutex_unlock(&l->mutex);
#else
up(&l->sem);
#endif
}
void
afs_mutex_enter(afs_kmutex_t * l)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
mutex_lock(&l->mutex);
#else
down(&l->sem);
#endif
if (l->owner)
osi_Panic("mutex_enter: 0x%lx held by %d", (unsigned long)l, l->owner);
l->owner = current->pid;
}
int
osi_NetReceive(osi_socket so, struct sockaddr_in *from, struct iovec *iov,
int iovcnt, int *lengthp)
{
struct msghdr msg;
int code;
#ifdef ADAPT_PMTU
int sockerr;
int esize;
#endif
struct iovec tmpvec[RX_MAXWVECS + 2];
struct socket *sop = (struct socket *)so;
if (iovcnt > RX_MAXWVECS + 2) {
osi_Panic("Too many (%d) iovecs passed to osi_NetReceive\n", iovcnt);
}
#ifdef ADAPT_PMTU
while (1) {
sockerr=0;
esize = sizeof(sockerr);
kernel_getsockopt(sop, SOL_SOCKET, SO_ERROR, (char *)&sockerr, &esize);
if (sockerr == 0)
break;
handle_socket_error(so);
}
#endif
memcpy(tmpvec, iov, iovcnt * sizeof(struct iovec));
msg.msg_name = from;
msg.msg_iov = tmpvec;
msg.msg_iovlen = iovcnt;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = 0;
code = kernel_recvmsg(sop, &msg, (struct kvec *)tmpvec, iovcnt,
*lengthp, 0);
if (code < 0) {
afs_try_to_freeze();
/* Clear the error before using the socket again.
* Oh joy, Linux has hidden header files as well. It appears we can
* simply call again and have it clear itself via sock_error().
*/
flush_signals(current); /* We don't want no stinkin' signals. */
rxk_lastSocketError = code;
rxk_nSocketErrors++;
} else {
*lengthp = code;
code = 0;
}
return code;
}
/*
* Given a dentry, return the file handle as encoded by the filesystem.
* We can't assume anything about the length (words, not bytes).
* The cache has to live on a single filesystem with uniform file
* handles, otherwise we panic.
*/
void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode) {
int max_len;
int type;
if (cache_fh_len > 0)
max_len = cache_fh_len;
else
max_len = MAX_FH_LEN;
type = afs_get_fh_from_dentry(dp, ainode, &max_len);
if (type == 255) {
osi_Panic("File handle encoding failed\n");
}
if (cache_fh_type < 0)
cache_fh_type = type;
if (cache_fh_len < 0) {
cache_fh_len = max_len;
}
if (type != cache_fh_type || max_len != cache_fh_len) {
osi_Panic("Inconsistent file handles within cache\n");
}
}
/*
* Simulate a blocking sendmsg on the non-blocking socket.
* It's non blocking because it was set that way for recvmsg.
*/
int
rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags)
{
fd_set *sfds = (fd_set *) 0;
while (sendmsg(socket, msg_p, flags) == -1) {
int err;
rx_stats.sendSelects++;
if (!sfds) {
if (!(sfds = IOMGR_AllocFDSet())) {
(osi_Msg "rx failed to alloc fd_set: ");
perror("rx_sendmsg");
return -1;
}
FD_SET(socket, sfds);
}
#if defined(HAVE_LINUX_ERRQUEUE_H) && defined(ADAPT_PMTU)
while((rxi_HandleSocketError(socket)) > 0)
;
#endif
#ifdef AFS_NT40_ENV
if (WSAGetLastError())
#elif defined(AFS_LINUX22_ENV)
/* linux unfortunately returns ECONNREFUSED if the target port
* is no longer in use */
/* and EAGAIN if a UDP checksum is incorrect */
if (errno != EWOULDBLOCK && errno != ENOBUFS && errno != ECONNREFUSED
&& errno != EAGAIN)
#else
if (errno != EWOULDBLOCK && errno != ENOBUFS)
#endif
{
(osi_Msg "rx failed to send packet: ");
perror("rx_sendmsg");
#ifndef AFS_NT40_ENV
if (errno > 0)
return -errno;
#else
if (WSAGetLastError() > 0)
return -WSAGetLastError();
#endif
return -1;
}
while ((err = select(socket + 1, 0, sfds, 0, 0)) != 1) {
if (err >= 0 || errno != EINTR)
osi_Panic("rxi_sendmsg: select error %d.%d", err, errno);
}
}
if (sfds)
IOMGR_FreeFDSet(sfds);
return 0;
}
void *
afs_MemCacheOpen(afs_dcache_id_t *ainode)
{
struct memCacheEntry *mep;
if (ainode->mem < 0 || ainode->mem > memMaxBlkNumber) {
osi_Panic("afs_MemCacheOpen: invalid block #");
}
mep = (memCache + ainode->mem);
afs_Trace3(afs_iclSetp, CM_TRACE_MEMOPEN, ICL_TYPE_INT32, ainode->mem,
ICL_TYPE_POINTER, mep, ICL_TYPE_POINTER, mep ? mep->data : 0);
return (void *)mep;
}
/**
* Decrement reference count to this connection.
* @param ac
* @param locktype
*/
void
afs_PutConn(struct afs_conn *ac, struct rx_connection *rxconn,
afs_int32 locktype)
{
AFS_STATCNT(afs_PutConn);
ac->refCount--;
if (ac->refCount < 0) {
osi_Panic("afs_PutConn: refcount imbalance 0x%lx %d",
(unsigned long)(uintptrsz)ac, (int)ac->refCount);
}
ac->parent->refCount--;
rx_PutConnection(rxconn);
} /*afs_PutConn */
void *
osi_UFSOpen(afs_int32 ainode)
{
struct osi_file *afile;
struct vnode *vp;
extern int cacheDiskType;
afs_int32 code;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
osi_Panic("UFSOpen called for non-UFS cache\n");
afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
AFS_GUNLOCK();
#if defined(AFS_FBSD50_ENV)
code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode, LK_EXCLUSIVE, &vp);
#else
code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode, &vp);
#endif
AFS_GLOCK();
if (code == 0 && vp->v_type == VNON)
code = ENOENT;
if (code) {
osi_FreeSmallSpace(afile);
osi_Panic("UFSOpen: igetinode failed");
}
#if defined(AFS_FBSD80_ENV)
VOP_UNLOCK(vp, 0);
#elif defined(AFS_FBSD50_ENV)
VOP_UNLOCK(vp, 0, curthread);
#else
VOP_UNLOCK(vp, 0, curproc);
#endif
afile->vnode = vp;
afile->size = VTOI(vp)->i_size;
afile->offset = 0;
afile->proc = NULL;
afile->inum = ainode; /* for hint validity checking */
return (void *)afile;
}
/* Generic read interface */
int
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
long resid;
afs_int32 code;
afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
* If the osi_file passed in is NULL, panic only if AFS is not shutting
* down. No point in crashing when we are already shutting down
*/
if (!afile) {
if (afs_shuttingdown == AFS_RUNNING)
osi_Panic("osi_Read called with null param");
else
return -EIO;
}
if (offset != -1)
afile->offset = offset;
retry_IO:
AFS_GUNLOCK();
code =
gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset,
AFS_UIOSYS, IO_UNIT, &resid);
AFS_GLOCK();
if (code == 0) {
code = asize - resid;
afile->offset += code;
osi_DisableAtimes(afile->vnode);
} else {
afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32,
(afs_int32) resid, ICL_TYPE_INT32, code);
/*
* To handle periodic low-level EFAULT failures that we've seen with the
* Weitek chip; in all observed failed cases a second read succeeded.
*/
if ((code == EFAULT) && (cnt1++ < 5)) {
afs_stats_cmperf.osiread_efaults++;
goto retry_IO;
}
setuerror(code);
if (code > 0) {
code *= -1;
}
}
return code;
}
/* Generic read interface */
int
afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
afs_size_t resid;
afs_int32 code;
#ifdef AFS_DARWIN80_ENV
uio_t uio;
#endif
AFS_STATCNT(osi_Read);
/**
* If the osi_file passed in is NULL, panic only if AFS is not shutting
* down. No point in crashing when we are already shutting down
*/
if (!afile) {
if (afs_shuttingdown == AFS_RUNNING)
osi_Panic("osi_Read called with null param");
else
return -EIO;
}
if (offset != -1)
afile->offset = offset;
AFS_GUNLOCK();
#ifdef AFS_DARWIN80_ENV
uio=uio_create(1, afile->offset, AFS_UIOSYS, UIO_READ);
uio_addiov(uio, CAST_USER_ADDR_T(aptr), asize);
code = VNOP_READ(afile->vnode, uio, IO_UNIT, afs_osi_ctxtp);
resid = AFS_UIO_RESID(uio);
uio_free(uio);
#else
code =
gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset,
AFS_UIOSYS, IO_UNIT, &afs_osi_cred, &resid);
#endif
AFS_GLOCK();
if (code == 0) {
code = asize - resid;
afile->offset += code;
osi_DisableAtimes(afile->vnode);
} else {
afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid,
ICL_TYPE_INT32, code);
if (code > 0) {
code *= -1;
}
}
return code;
}
void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct osi_file *afile = NULL;
extern int cacheDiskType;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
osi_Panic("UFSOpen called for non-UFS cache\n");
}
if (!afs_osicred_initialized) {
memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
AFS_GUNLOCK();
afile = kmalloc(sizeof(struct osi_file), GFP_NOFS);
if (!afile) {
osi_Panic("osi_UFSOpen: Failed to allocate %d bytes for osi_file.\n",
(int)sizeof(struct osi_file));
}
memset(afile, 0, sizeof(struct osi_file));
afile->filp = afs_linux_raw_open(ainode);
if (afile->filp) {
afile->size = i_size_read(FILE_INODE(afile->filp));
}
AFS_GLOCK();
if (!afile->filp) {
osi_FreeLargeSpace(afile);
return NULL;
}
afile->offset = 0;
afile->proc = (int (*)())0;
return (void *)afile;
}
vnode_t *
afs_XFSIGetVnode(ino_t ainode)
{
struct xfs_inode *ip;
int error;
vnode_t *vp;
if ((error =
xfs_igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode, &ip))) {
osi_Panic("afs_XFSIGetVnode: xfs_igetinode failed, error=%d", error);
}
vp = XFS_ITOV(ip);
return vp;
}
cred_t *
crget(void)
{
cred_t *tmp;
#if !defined(GFP_NOFS)
#define GFP_NOFS GFP_KERNEL
#endif
tmp = kmalloc(sizeof(cred_t), GFP_NOFS);
if (!tmp)
osi_Panic("crget: No more memory for creds!\n");
tmp->cr_ref = 1;
return tmp;
}
void *
osi_UFSOpen(afs_int32 ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
int dummy;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
osi_Panic("UFSOpen called for non-UFS cache\n");
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
setuerror(0);
AFS_GUNLOCK();
ip = (struct inode *)igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev,
(ino_t) ainode, &dummy);
AFS_GLOCK();
if (getuerror()) {
osi_FreeSmallSpace(afile);
osi_Panic("UFSOpen: igetinode failed");
}
iunlock(ip);
afile->vnode = ITOV(ip);
afile->size = VTOI(afile->vnode)->i_size;
afile->offset = 0;
afile->proc = (int (*)())0;
afile->inum = ainode; /* for hint validity checking */
return (void *)afile;
}
/*
* Start an Rx server process.
*/
void
rxi_StartServerProc(void *(*proc) (void *), int stacksize)
{
pthread_t thread;
pthread_attr_t tattr;
AFS_SIGSET_DECL;
if (pthread_attr_init(&tattr) != 0) {
osi_Panic("Unable to Create Rx server thread (pthread_attr_init)\n");
}
if (pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) != 0) {
osi_Panic("Unable to Create Rx server thread (pthread_attr_setdetachstate)\n");
}
/*
* NOTE: We are ignoring the stack size parameter, for now.
*/
AFS_SIGSET_CLEAR();
if (pthread_create(&thread, &tattr, server_entry, (void *)proc) != 0) {
osi_Panic("Unable to Create Rx server thread\n");
}
AFS_SIGSET_RESTORE();
}
cred_t *
crget(void)
{
cred_t *tmp;
tmp = kmalloc(sizeof(cred_t), GFP_NOFS);
if (!tmp)
osi_Panic("crget: No more memory for creds!\n");
#if defined(STRUCT_TASK_STRUCT_HAS_CRED)
get_cred(tmp);
#else
atomic_set(&tmp->cr_ref, 1);
#endif
return tmp;
}
int
osi_NetReceive(osi_socket so, struct sockaddr_in *from, struct iovec *iov,
int iovcnt, int *lengthp)
{
struct msghdr msg;
int code;
struct iovec tmpvec[RX_MAXWVECS + 2];
struct socket *sop = (struct socket *)so;
if (iovcnt > RX_MAXWVECS + 2) {
osi_Panic("Too many (%d) iovecs passed to osi_NetReceive\n", iovcnt);
}
memcpy(tmpvec, iov, iovcnt * sizeof(struct iovec));
msg.msg_name = from;
#if defined(STRUCT_MSGHDR_HAS_MSG_ITER)
msg.msg_iter.iov = tmpvec;
msg.msg_iter.nr_segs = iovcnt;
#else
msg.msg_iov = tmpvec;
msg.msg_iovlen = iovcnt;
#endif
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = 0;
code = kernel_recvmsg(sop, &msg, (struct kvec *)tmpvec, iovcnt,
*lengthp, 0);
if (code < 0) {
afs_try_to_freeze();
/* Clear the error before using the socket again.
* Oh joy, Linux has hidden header files as well. It appears we can
* simply call again and have it clear itself via sock_error().
*/
flush_signals(current); /* We don't want no stinkin' signals. */
rxk_lastSocketError = code;
rxk_nSocketErrors++;
do_handlesocketerror(so);
} else {
*lengthp = code;
code = 0;
}
return code;
}
ino_t
VnodeToIno(vnode_t * vp)
{
int code;
struct vattr vattr;
vattr.va_mask = AT_FSID | AT_NODEID; /* quick return using this mask. */
#ifdef AFS_SUN511_ENV
code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp, NULL);
#else
code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp);
#endif
if (code) {
osi_Panic("VnodeToIno");
}
return vattr.va_nodeid;
}
/* Generic write interface */
int
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
unsigned int resid;
afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
if (offset != -1)
afile->offset = offset;
/* Note the difference in the way the afile->offset is passed (see comments in gop_rdwr() in afs_aix_subr.c for comments) */
AFS_GUNLOCK();
#ifdef AFS_64BIT_KERNEL
code =
gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
&afile->offset, AFS_UIOSYS, NULL, &resid);
#else
code =
gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
(off_t) & afile->offset, AFS_UIOSYS, NULL, &resid);
#endif
AFS_GLOCK();
if (code == 0) {
if (resid)
afs_Trace3(afs_iclSetp, CM_TRACE_WRITEFAILED, ICL_TYPE_INT32,
asize, ICL_TYPE_INT32, resid, ICL_TYPE_INT32, code);
code = asize - resid;
afile->offset += code;
} else {
afs_Trace3(afs_iclSetp, CM_TRACE_WRITEFAILED, ICL_TYPE_INT32, asize,
ICL_TYPE_INT32, resid, ICL_TYPE_INT32, code);
if (code == ENOSPC)
afs_warnuser
("\n\n\n*** Cache partition is FULL - Decrease cachesize!!! ***\n\n");
setuerror(code);
if (code > 0) {
code = -code;
}
}
if (afile->proc) {
(*afile->proc) (afile, code);
}
return code;
}
/**
* In Solaris 7 we use 64 bit inode numbers
*/
void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
extern int cacheDiskType;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
osi_Panic("UFSOpen called for non-UFS cache\n");
}
if (!afs_osicred_initialized) {
afs_osi_credp = kcred;
afs_osicred_initialized = 1;
}
#ifdef AFS_HAVE_VXFS
if (afs_CacheFSType == AFS_SUN_VXFS_CACHE)
return osi_VxfsOpen(ainode);
#endif
return osi_UfsOpen(ainode);
}
/* Generic write interface */
int
afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
afs_size_t resid;
afs_int32 code;
#ifdef AFS_DARWIN80_ENV
uio_t uio;
#endif
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
if (offset != -1)
afile->offset = offset;
{
AFS_GUNLOCK();
#ifdef AFS_DARWIN80_ENV
uio=uio_create(1, afile->offset, AFS_UIOSYS, UIO_WRITE);
uio_addiov(uio, CAST_USER_ADDR_T(aptr), asize);
code = VNOP_WRITE(afile->vnode, uio, IO_UNIT, afs_osi_ctxtp);
resid = AFS_UIO_RESID(uio);
uio_free(uio);
#else
code =
gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
afile->offset, AFS_UIOSYS, IO_UNIT, &afs_osi_cred,
&resid);
#endif
AFS_GLOCK();
}
if (code == 0) {
code = asize - resid;
afile->offset += code;
} else {
if (code > 0) {
code *= -1;
}
}
if (afile->proc) {
(*afile->proc) (afile, code);
}
return code;
}
