aboutsummaryrefslogtreecommitdiffstats
path: root/arch/arm/mvp/mvpkm/mksck_kernel.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/arm/mvp/mvpkm/mksck_kernel.c')
-rw-r--r--arch/arm/mvp/mvpkm/mksck_kernel.c2589
1 files changed, 0 insertions, 2589 deletions
diff --git a/arch/arm/mvp/mvpkm/mksck_kernel.c b/arch/arm/mvp/mvpkm/mksck_kernel.c
deleted file mode 100644
index 6811a68..0000000
--- a/arch/arm/mvp/mvpkm/mksck_kernel.c
+++ /dev/null
@@ -1,2589 +0,0 @@
-/*
- * Linux 2.6.32 and later Kernel module for VMware MVP Hypervisor Support
- *
- * Copyright (C) 2010-2012 VMware, Inc. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; see the file COPYING. If not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-#line 5
-
-/**
- * @file
- *
- * @brief The monitor/kernel socket interface kernel extension.
- */
-
-#define __KERNEL_SYSCALLS__
-#include <linux/version.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/fs.h>
-#include <linux/errno.h>
-#include <linux/types.h>
-#include <linux/proc_fs.h>
-#include <linux/fcntl.h>
-#include <linux/syscalls.h>
-#include <linux/kmod.h>
-#include <linux/socket.h>
-#include <linux/net.h>
-#include <linux/skbuff.h>
-#include <linux/miscdevice.h>
-#include <linux/poll.h>
-#include <linux/rcupdate.h>
-#include <linux/smp.h>
-#include <linux/spinlock.h>
-
-#include <linux/mm.h>
-#include <linux/mman.h>
-#include <linux/file.h>
-#include <linux/vmalloc.h>
-
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-
-#include <net/sock.h>
-
-#include <asm/memory.h>
-#include <asm/system.h>
-#include <asm/uaccess.h>
-
-#include "mvp.h"
-#include "actions.h"
-#include "mvpkm_kernel.h"
-#include "mksck_kernel.h"
-#include "mksck_sockaddr.h"
-#include "mutex_kernel.h"
-
-void NORETURN FatalError(char const *file,
- int line,
- FECode feCode,
- int bugno,
- char const *fmt,
- ...)
-{
- /* Lock around printing the error details so that the messages from multiple
- * threads are not interleaved. */
- static DEFINE_MUTEX(fatalErrorMutex);
- mutex_lock(&fatalErrorMutex);
-
- FATALERROR_COMMON(printk, vprintk, file, line, feCode, bugno, fmt);
-
- dump_stack();
-
- /* done printing */
- mutex_unlock(&fatalErrorMutex);
-
- /* do_exit below exits the current thread but does not crash the kernel.
- * Hence the stack dump will actually be readable from other user threads.
- */
- do_exit(1);
-}
-
-
-/*
- * The project uses a new address family: AF_MKSCK. Optimally this address
- * family were accepted with the Linux community and a permanent number
- * were assigned. This, however, is a dream only, not even the x86 team
- * has been able to pull it off.
- *
- * Instead we ASSUME that DECnet is dead and re-use it's address family number.
- * This is what the x86 world is moving too in the latest versions.
- */
-
-static struct proto mksckProto = {
- .name = "AF_MKSCK",
- .owner = THIS_MODULE,
- .obj_size = sizeof (struct sock),
-};
-
-static int MksckCreate(struct net *net,
- struct socket *sock,
- int protocol,
- int kern);
-
-static struct net_proto_family mksckFamilyOps = {
- .family = AF_MKSCK,
- .owner = THIS_MODULE,
- .create = MksckCreate,
-};
-
-static int MksckFault(struct vm_area_struct *vma, struct vm_fault *vmf);
-
-
-/**
- * @brief Linux vma operations for receive windows established via Mksck
- * mmap.
- */
-static struct vm_operations_struct mksckVMOps = {
- .fault = MksckFault
-};
-
-/*
- * List of hosts and guests we know about.
- */
-static spinlock_t mksckPageListLock;
-static MksckPage *mksckPages[MKSCK_MAX_SHARES];
-
-/*
- * The following functions form the AF_MKSCK DGRAM operations.
- */
-static int MksckRelease(struct socket *sock);
-static int MksckBacklogRcv(struct sock *sk, struct sk_buff *skb);
-static void MksckSkDestruct(struct sock *sk);
-static int MksckBind(struct socket *sock,
- struct sockaddr *addr,
- int addrLen);
-static int MksckBindGeneric(struct sock *sk,
- Mksck_Address addr);
-static int MksckDgramRecvMsg(struct kiocb *kiocb,
- struct socket *sock,
- struct msghdr *msg,
- size_t len,
- int flags);
-static int MksckDgramSendMsg(struct kiocb *kiocb,
- struct socket *sock,
- struct msghdr *msg,
- size_t len);
-static int MksckGetName(struct socket *sock,
- struct sockaddr *addr,
- int *addrLen,
- int peer);
-static unsigned int MksckPoll(struct file *filp,
- struct socket *sock,
- poll_table *wait);
-static int MksckDgramConnect(struct socket *sock,
- struct sockaddr *addr,
- int addrLen,
- int flags);
-static int MksckMMap(struct file *file,
- struct socket *sock,
- struct vm_area_struct *vma);
-
-static void MksckPageRelease(MksckPage *mksckPage);
-
-static struct proto_ops mksckDgramOps = {
- .family = AF_MKSCK,
- .owner = THIS_MODULE,
- .release = MksckRelease,
- .bind = MksckBind,
- .connect = MksckDgramConnect,
- .socketpair = sock_no_socketpair,
- .accept = sock_no_accept,
- .getname = MksckGetName,
- .poll = MksckPoll,
- .ioctl = sock_no_ioctl,
- .listen = sock_no_listen,
- .shutdown = sock_no_shutdown, /* MksckShutdown, */
- .setsockopt = sock_no_setsockopt,
- .getsockopt = sock_no_getsockopt,
- .sendmsg = MksckDgramSendMsg,
- .recvmsg = MksckDgramRecvMsg,
- .mmap = MksckMMap,
- .sendpage = sock_no_sendpage,
-};
-
-
-/**
- * @brief Initialize the MKSCK protocol
- *
- * @return 0 on success, -errno on failure
- */
-int
-Mksck_Init(void)
-{
- int err;
-
- spin_lock_init(&mksckPageListLock);
-
- /*
- * Create a slab to allocate socket structs from.
- */
- err = proto_register(&mksckProto, 1);
- if (err != 0) {
- printk(KERN_INFO
- "Mksck_Init: Cannot register MKSCK protocol, errno = %d.\n", err);
- return err;
- }
-
- /*
- * Register the socket family
- */
- err = sock_register(&mksckFamilyOps);
- if (err < 0) {
- printk(KERN_INFO
- "Mksck_Init: Could not register address family AF_MKSCK"
- " (errno = %d).\n", err);
- return err;
- }
-
- return 0;
-}
-
-
-/**
- * @brief De-register the MKSCK protocol
- */
-void
-Mksck_Exit(void)
-{
- sock_unregister(mksckFamilyOps.family);
- proto_unregister(&mksckProto);
-}
-
-
-/**
- * @brief Create a new MKSCK socket
- *
- * @param net network namespace (2.6.24 or above)
- * @param sock user socket structure
- * @param protocol protocol to be used
- * @param kern called from kernel mode
- *
- * @return 0 on success, -errno on failure
- */
-static int
-MksckCreate(struct net *net,
- struct socket *sock,
- int protocol,
- int kern)
-{
- struct sock *sk;
- uid_t currentUid = current_euid();
-
- if (!(currentUid == 0 ||
- currentUid == Mvpkm_vmwareUid)) {
- printk(KERN_WARNING
- "MksckCreate: rejected from process %s tgid=%d, pid=%d euid:%d.\n",
- current->comm,
- task_tgid_vnr(current),
- task_pid_vnr(current),
- currentUid);
- return -EPERM;
- }
-
- if (!sock) {
- return -EINVAL;
- }
-
- if (protocol) {
- return -EPROTONOSUPPORT;
- }
-
- switch (sock->type) {
- case SOCK_DGRAM: {
- sock->ops = &mksckDgramOps;
- break;
- }
- default: {
- return -ESOCKTNOSUPPORT;
- }
- }
-
- sock->state = SS_UNCONNECTED;
-
- /*
- * Most recently (in 2.6.24), sk_alloc() was changed to expect the
- * network namespace, and the option to zero the sock was dropped.
- */
- sk = sk_alloc(net, mksckFamilyOps.family, GFP_KERNEL, &mksckProto);
-
- if (!sk) {
- return -ENOMEM;
- }
-
- sock_init_data(sock, sk);
-
- sk->sk_type = SOCK_DGRAM;
- sk->sk_destruct = MksckSkDestruct;
- sk->sk_backlog_rcv = MksckBacklogRcv;
-
- /*
- * On socket lock...
- *
- * A bound socket will have an associated private area, the Mksck
- * structure part of MksckPage. That area is pointed to by
- * sk->sk_protinfo. In addition, a connected socket will have the
- * peer field in its associated area set to point to the associated
- * private area of the peer socket. A mechanism is needed to ensure
- * that these private areas area not freed while they are being
- * accessed within the scope of a function. A simple lock would not
- * suffice as the interface functions (like MksckDgramRecvMsg())
- * may block. Hence a reference count mechanism is employed. When
- * the mentioned references (sk->sk_protinfo and mksck->peer) to
- * the respective private areas are set a refcount is incremented,
- * and decremented when the references are deleted.
- *
- * The refcounts of areas pointed to by sk->sk_protinfo and
- * mksck->peer will be decremented under the lock of the socket.
- * Hence these private areas cannot disappear as long as the socket
- * lock is held.
- *
- * The interface functions will have one of the following
- * structures:
- *
- * simpleFn(sk)
- * {
- * lock_sock(sk);
- * if ((mksck = sk->sk_protinfo)) {
- * <non-blocking use of mksck>
- * }
- * release_sock(sk);
- * }
- *
- * complexFn(sk)
- * {
- * lock_sock(sk);
- * if ((mksck = sk->sk_protinfo)) {
- * IncRefc(mksck);
- * }
- * release_sock(sk);
- *
- * if (mksck) {
- * <use of mksck in a potentially blocking manner>
- * DecRefc(mksck);
- * }
- * }
- */
- sk->sk_protinfo = NULL;
- sock_reset_flag(sk, SOCK_DONE);
-
- return 0;
-}
-
-
-/**
- * @brief Delete a MKSCK socket
- *
- * @param sock user socket structure
- *
- * @return 0 on success, -errno on failure
- */
-static int
-MksckRelease(struct socket *sock)
-{
- struct sock *sk = sock->sk;
-
- if (sk) {
- lock_sock(sk);
- sock_orphan(sk);
- release_sock(sk);
- sock_put(sk);
- }
-
- sock->sk = NULL;
- sock->state = SS_FREE;
-
- return 0;
-}
-
-
-static int
-MksckBacklogRcv(struct sock *sk, struct sk_buff *skb)
-{
- /*
- * We should never get these as we never queue an skb.
- */
- printk("MksckBacklogRcv: should never get here\n");
- return -EIO;
-}
-
-
-/**
- * @brief Callback at socket destruction
- *
- * @param sk pointer to kernel socket structure
- */
-static void
-MksckSkDestruct(struct sock *sk)
-{
- Mksck *mksck;
-
- lock_sock(sk);
- mksck = sk->sk_protinfo;
-
- if (mksck != NULL) {
- sk->sk_protinfo = NULL;
- Mksck_CloseCommon(mksck);
- }
-
- if (sk->sk_user_data != NULL) {
- sock_kfree_s(sk, sk->sk_user_data, sizeof(int));
- sk->sk_user_data = NULL;
- }
-
- release_sock(sk);
-}
-
-
-/**
- * @brief Set the local address of a MKSCK socket
- *
- * @param sk kernel socket structure
- * @param addr the new address of the socket
- *
- * @return 0 on success, -errno on failure
- *
- * If addr.port is undefined a new random port is assigned.
- * If addr.vmId is undefined then the vmId computed from the tgid is used.
- * Hence the vmId of a socket does not determine the host all the time.
- *
- * Assumed that the socket is locked.
- * This function is called by explicit set (MksckBind) and implicit (Send).
- */
-static int
-MksckBindGeneric(struct sock *sk,
- Mksck_Address addr)
-{
- int err;
- Mksck *mksck;
- MksckPage *mksckPage;
-
- if (sk->sk_protinfo != NULL) {
- return -EISCONN;
- }
-
- /*
- * Locate the page for the given host and increment its reference
- * count so it can't get freed off while we are working on it.
- */
- if (addr.vmId == MKSCK_VMID_UNDEF) {
- mksckPage = MksckPage_GetFromTgidIncRefc();
- } else {
- printk(KERN_WARNING "MksckBind: host bind called on vmid 0x%X\n", addr.vmId);
- mksckPage = MksckPage_GetFromVmIdIncRefc(addr.vmId);
- }
-
- if (mksckPage == NULL) {
- printk(KERN_INFO "MksckBind: no mksckPage for vm 0x%X\n", addr.vmId);
- return -ENETUNREACH;
- }
- addr.vmId = mksckPage->vmId;
-
- /*
- * Before we can find an unused socket port on the page we have to
- * lock the page for exclusive access so another thread can't
- * allocate the same port.
- */
- err = Mutex_Lock(&mksckPage->mutex, MutexModeEX);
- if (err < 0) {
- goto outDec;
- }
-
- addr.port = MksckPage_GetFreePort(mksckPage, addr.port);
- if (addr.port == MKSCK_PORT_UNDEF) {
- err = -EINVAL;
- goto outUnlockDec;
- }
-
- /*
- * At this point we have the mksckPage locked for exclusive access
- * and its reference count incremented. Also, addr is completely
- * filled in with vmId and port that we want to bind.
- *
- * Find an available mksck struct on the shared page and initialize
- * it.
- */
- mksck = MksckPage_AllocSocket(mksckPage, addr);
- if (mksck == NULL) {
- err = -EMFILE;
- goto outUnlockDec;
- }
-
- /*
- * Stable, release mutex. Leave mksckPage->refCount incremented so
- * mksckPage can't be freed until socket is closed.
- */
- Mutex_Unlock(&mksckPage->mutex, MutexModeEX);
-
- /*
- * This is why we start mksck->refCount at 1. When sk_protinfo gets
- * cleared, we decrement mksck->refCount.
- */
- sk->sk_protinfo = mksck;
-
- PRINTK(KERN_DEBUG "MksckBind: socket bound to %08X\n", mksck->addr.addr);
-
- return 0;
-
-outUnlockDec:
- Mutex_Unlock(&mksckPage->mutex, MutexModeEX);
-outDec:
- MksckPage_DecRefc(mksckPage);
- return err;
-}
-
-
-/**
- * @brief Test if the socket is already bound to a local address and,
- * if not, bind it to an unused address.
- *
- * @param sk kernel socket structure
- * @return 0 on success, -errno on failure
- *
- * Assumed that the socket is locked.
- */
-static inline int
-MksckTryBind(struct sock *sk)
-{
- int err = 0;
-
- if (!sk->sk_protinfo) {
- static const Mksck_Address addr = { .addr = MKSCK_ADDR_UNDEF };
- err = MksckBindGeneric(sk, addr);
- }
- return err;
-}
-
-
-
-/**
- * @brief Set the address of a MKSCK socket (user call)
- *
- * @param sock user socket structure
- * @param addr the new address of the socket
- * @param addrLen length of the address
- *
- * @return 0 on success, -errno on failure
- */
-static int
-MksckBind(struct socket *sock,
- struct sockaddr *addr,
- int addrLen)
-{
- int err;
- struct sock *sk = sock->sk;
- struct sockaddr_mk *addrMk = (struct sockaddr_mk *)addr;
-
- if (addrLen != sizeof *addrMk) {
- return -EINVAL;
- }
- if (addrMk->mk_family != AF_MKSCK) {
- return -EAFNOSUPPORT;
- }
-
- /*
- * Obtain the socket lock and call the generic Bind function.
- */
- lock_sock(sk);
- err = MksckBindGeneric(sk, addrMk->mk_addr);
- release_sock(sk);
-
- return err;
-}
-
-/**
- * @brief Lock the peer socket by locating it, incrementing its refc
- * @param addr the address of the peer socket
- * @param[out] peerMksckR set to the locked peer socket pointer
- * upon successful lookup
- * @return 0 on success, -errno on failure
- */
-static int
-LockPeer(Mksck_Address addr, Mksck **peerMksckR)
-{
- int err = 0;
- MksckPage *peerMksckPage = MksckPage_GetFromVmIdIncRefc(addr.vmId);
- Mksck *peerMksck;
-
- /*
- * Find corresponding destination shared page and increment its
- * reference count so it can't be freed while we are sending to the
- * socket. Make sure that the address is indeed an address of a
- * monitor/guest socket.
- */
- if (peerMksckPage == NULL) {
- printk(KERN_INFO "LockPeer: vmId %x is not in use!\n", addr.vmId);
- return -ENETUNREACH;
- }
- if (!peerMksckPage->isGuest) {
- MksckPage_DecRefc(peerMksckPage);
- printk(KERN_INFO "LockPeer: vmId %x does not belong to a guest!\n",
- addr.vmId);
- return -ENETUNREACH;
- }
-
-
- err = Mutex_Lock(&peerMksckPage->mutex, MutexModeSH);
- if (err < 0) {
- MksckPage_DecRefc(peerMksckPage);
- return err;
- }
-
- /*
- * Find corresponding destination socket on that shared page and
- * increment its reference count so it can't be freed while we are
- * trying to send to it.
- */
- peerMksck = MksckPage_GetFromAddr(peerMksckPage, addr);
-
- if (peerMksck) {
- ATOMIC_ADDV(peerMksck->refCount, 1);
- *peerMksckR = peerMksck;
- } else {
- printk(KERN_INFO "LockPeer: addr %x is not a defined socket!\n",
- addr.addr);
- err = -ENETUNREACH;
- }
-
- Mutex_Unlock(&peerMksckPage->mutex, MutexModeSH);
- MksckPage_DecRefc(peerMksckPage);
- return err;
-}
-
-/**
- * @brief Set the peer address of a MKSCK socket
- *
- * @param sock user socket structure
- * @param addr the new address of the socket
- * @param addrLen length of the address
- * @param flags flags
- *
- * @return 0 on success, -errno on failure
- */
-static int
-MksckDgramConnect(struct socket *sock,
- struct sockaddr *addr,
- int addrLen,
- int flags)
-{
- struct sock *sk = sock->sk;
- Mksck *mksck;
- struct sockaddr_mk *peerAddrMk = (struct sockaddr_mk *)addr;
- int err = 0;
-
- if (addrLen != sizeof *peerAddrMk) {
- printk(KERN_INFO "MksckConnect: wrong address length!\n");
- return -EINVAL;
- }
- if (peerAddrMk->mk_family != AF_MKSCK) {
- printk(KERN_INFO "MksckConnect: wrong address family!\n");
- return -EAFNOSUPPORT;
- }
-
- lock_sock(sk);
-
- if ((err = MksckTryBind(sk))) {
- goto releaseSock;
- }
- mksck = sk->sk_protinfo;
-
- /*
- * First severe any past peer connections
- */
- Mksck_DisconnectPeer(mksck);
- sock->state = SS_UNCONNECTED;
-
- /*
- * Then build new connections ...
- */
- if (peerAddrMk->mk_addr.addr != MKSCK_ADDR_UNDEF) {
- sock->state = SS_CONNECTED;
- mksck->peerAddr = peerAddrMk->mk_addr;
- err = LockPeer(mksck->peerAddr, &mksck->peer);
- PRINTK(KERN_DEBUG "MksckConnect: socket %x is connected to %x!\n",
- mksck->addr.addr, mksck->peerAddr.addr);
- }
-
-releaseSock:
- release_sock(sk);
-
- return err;
-}
-
-
-/**
- * @brief returns the address of a MKSCK socket/peer address
- *
- * @param sock user socket structure
- * @param addr the new address of the socket
- * @param addrLen length of the address
- * @param peer 1 if the peer address is sought
- *
- * @return 0 on success, -errno on failure
- */
-static int
-MksckGetName(struct socket *sock,
- struct sockaddr *addr,
- int *addrLen,
- int peer)
-{
- int err;
- Mksck *mksck;
- struct sock *sk = sock->sk;
-
- // MAX_SOCK_ADDR is size of *addr, Linux doesn't export it!
- // ASSERT_ON_COMPILE(sizeof (struct sockaddr_mk) <= MAX_SOCK_ADDR);
-
- lock_sock(sk);
- mksck = sk->sk_protinfo;
-
- if (mksck == NULL) {
- if (peer) {
- err = -ENOTCONN;
- } else {
- ((struct sockaddr_mk *)addr)->mk_family = AF_MKSCK;
- ((struct sockaddr_mk *)addr)->mk_addr.addr = MKSCK_ADDR_UNDEF;
- *addrLen = sizeof (struct sockaddr_mk);
- err = 0;
- }
- } else if (!peer) {
- ((struct sockaddr_mk *)addr)->mk_family = AF_MKSCK;
- ((struct sockaddr_mk *)addr)->mk_addr = mksck->addr;
- *addrLen = sizeof (struct sockaddr_mk);
- err = 0;
- } else if (mksck->peerAddr.addr == MKSCK_ADDR_UNDEF) {
- err = -ENOTCONN;
- } else {
- ((struct sockaddr_mk *)addr)->mk_family = AF_MKSCK;
- ((struct sockaddr_mk *)addr)->mk_addr = mksck->peerAddr;
- *addrLen = sizeof (struct sockaddr_mk);
- err = 0;
- }
-
- release_sock(sk);
-
- return err;
-}
-
-
-/**
- * @brief VMX polling a receipted packet from VMM.
- *
- * @param filp kernel file pointer to poll for
- * @param sock user socket structure
- * @param wait kernel polling table where to poll if not null
- *
- * @return poll mask state given from socket state.
- */
-static unsigned int MksckPoll(struct file *filp,
- struct socket *sock,
- poll_table *wait)
-{
- struct sock *sk = sock->sk;
- unsigned int mask = 0;
- Mksck *mksck = NULL;
- uint32 read;
- int err;
-
- lock_sock(sk);
- if ((err = MksckTryBind(sk))) {
- release_sock(sk);
- return err;
- }
- mksck = sk->sk_protinfo;
-
- /*
- * To avoid mksck disappearing right after the release_sock the
- * refcount needs to be incremented. For more details read the
- * block comment on locking in MksckCreate.
- */
- ATOMIC_ADDV(mksck->refCount, 1);
- release_sock(sk);
-
- /*
- * Wait to make sure this is the only thread trying to access socket.
- */
- if ((err = Mutex_Lock(&mksck->mutex, MutexModeEX)) < 0) {
- /* we might get in this situation if we are signaled
- (select() may handle this, so leave) */
- PRINTK(KERN_INFO "MksckPoll: try to abort\n");
- return mask;
- }
-
- /*
- * See if packet in ring.
- */
- read = mksck->read;
- if (read != mksck->write) {
- mask |= POLLIN | POLLRDNORM; /* readable, socket is unlocked */
- /* Note that if we are implementing support for POLLOUT, we SHOULD
- change this Mutex_Unlock by Mutex_UnlPoll, because there is no
- obvious knowledge about the sleepy reason that is intended by user */
- Mutex_Unlock(&mksck->mutex, MutexModeEX);
- } else {
- Mutex_UnlPoll(&mksck->mutex, MutexModeEX, MKSCK_CVAR_FILL, filp, wait);
- }
-
- /*
- * Note that locking rules differ a little inside MksckPoll, since we are
- * not only given a pointer to the struct socket but also a pointer to a
- * struct file. This means that during the whole operation of this function
- * and during any pending wait (registered with poll_wait()), the file itself
- * is reference counted up, and we should rely on that 'upper' reference
- * counting to prevent from tearing the Mksck down. That holds true since one
- * never re-bind sockets !
- */
- Mksck_DecRefc(mksck);
- return mask;
-}
-
-/**
- * @brief Manage a set of Mksck_PageDesc from a message or a stored array.
- *
- * @param pd set of Mksck_PageDesc
- * @param pages Mksck_PageDesc pages count for this management operation
- * @param incr ternary used to indicate if we want to reference (+1), or
- * dereference (-1), or count (0) 4k pages
- *
- * @return length of bytes processed.
- */
-static size_t
-MksckPageDescManage(Mksck_PageDesc *pd,
- uint32 pages,
- int incr)
-{
- size_t payloadLen = 0;
- uint32 i;
-
- for (i = 0; i < pages && pd[i].mpn != INVALID_MPN; ++i) {
- uint32 j;
-
- for (j = 0; j < 1 << pd[i].order; ++j) {
- struct page *page;
- MPN currMPN = pd[i].mpn + j;
-
- /*
- * The monitor tried to send an invalid MPN, bad.
- */
- if (!pfn_valid(currMPN)) {
- printk("MksckPageDescManage: Invalid MPN %x\n", currMPN);
- } else {
- page = pfn_to_page(currMPN);
-
- if (incr == +1) {
- get_page(page);
- }
- if (incr == -1) {
- put_page(page);
- }
- }
-
- payloadLen += PAGE_SIZE;
- }
- }
-
- return payloadLen;
-}
-
-/**
- * @brief Management values to be used as third parameter of MksckPageDescManage
- */
-#define MANAGE_INCREMENT +1
-#define MANAGE_DECREMENT -1
-#define MANAGE_COUNT 0
-
-
-/**
- * @brief Map a set of Mksck_PageDesc from a message or a stored array.
- *
- * @param pd set of Mksck_PageDesc
- * @param pages pages count for this mapping
- * @param iov vectored user virtual addresses of the recv commands
- * @param iovCount size for iov parameter
- * @param vma virtual memory area used for the mapping, note that
- * this is mandatorily required MksckPageDescMap is used
- * on an indirect PageDesc context (i.e whenever iov is
- * not computed by the kernel but by ourselves).
- *
- * Since find_vma() and vm_insert_page() are used, this function must
- * be called with current's mmap_sem locked, or inside an MMap operation.
- *
- * @return length of bytes mapped.
- */
-static size_t
-MksckPageDescMap(Mksck_PageDesc *pd,
- uint32 pages,
- struct iovec *iov,
- int iovCount,
- struct vm_area_struct *vma)
-{
- size_t payloadLen = 0;
- uint32 i;
-
- for (i = 0; i < pages && pd[i].mpn != INVALID_MPN; ++i) {
- uint32 j;
-
- for (j = 0; j < 1 << pd[i].order; ++j) {
- HUVA huva = 0;
- struct page *page;
- MPN currMPN = pd[i].mpn + j;
-
- while (iovCount > 0 && iov->iov_len == 0) {
- iovCount--;
- iov++;
- }
-
- if (iovCount == 0) {
- printk("MksckPageDescMap: Invalid iov length\n");
- goto map_done;
- }
-
- huva = (HUVA)iov->iov_base;
-
- /*
- * iovecs for receiving the typed component of the message should
- * have page aligned base and size sufficient for page descriptor's
- * mappings.
- */
- if (huva & (PAGE_SIZE - 1) || iov->iov_len < PAGE_SIZE) {
- printk("MksckPageDescMap: Invalid huva %x or iov_len %d\n",
- huva,
- iov->iov_len);
- goto map_done;
- }
-
- /*
- * Might be in a new vma...
- */
- if (vma == NULL || huva < vma->vm_start || huva >= vma->vm_end) {
- vma = find_vma(current->mm, huva);
-
- /*
- * Couldn't find a matching vma for huva.
- */
- if (vma == NULL ||
- huva < vma->vm_start ||
- vma->vm_ops != &mksckVMOps) {
- printk("MksckPageDescMap: Invalid vma\n");
- goto map_done;
- }
- }
-
- /*
- * The monitor tried to send an invalid MPN, bad.
- */
- if (!pfn_valid(currMPN)) {
- printk("MksckPageDescMap: Invalid MPN %x\n", currMPN);
- } else {
- int rc;
-
- page = pfn_to_page(currMPN);
-
- /*
- * Map into the receive window.
- */
- rc = vm_insert_page(vma, huva, page);
- if (rc) {
- printk("MksckPageDescMap: Failed to insert %x at %x, error %d\n",
- currMPN,
- huva,
- rc);
- goto map_done;
- }
-
- ASSERT(iov->iov_len >= PAGE_SIZE);
- iov->iov_base += PAGE_SIZE;
- iov->iov_len -= PAGE_SIZE;
- }
-
- payloadLen += PAGE_SIZE;
- }
- }
-
-map_done:
- return payloadLen;
-}
-
-
-/**
- * @brief Check if the provided MsgHdr has still room for a receive operation.
- *
- * @param msg user buffer
- * @return 1 if MsgHdr has IO space room in order to receive a mapping, 0 otherwise.
- */
-static int
-MsgHdrHasAvailableRoom(struct msghdr *msg)
-{
- struct iovec *vec = msg->msg_iov;
- uint32 count = msg->msg_iovlen;
-
- while (count > 0 && vec->iov_len == 0) {
- count--;
- vec++;
- }
-
- return (count != 0);
-}
-
-
-/**
- * Whenever a typed message is received from the monitor, we may choose to store
- * all the page descriptor content in a linked state of descriptors, through the
- * following information context
- */
-typedef struct MksckPageDescInfo {
- struct MksckPageDescInfo *next;
- uint32 flags;
- uint32 pages;
- uint32 mapCounts;
- Mksck_PageDesc descs[0];
-} MksckPageDescInfo;
-
-static void MksckPageDescSkDestruct(struct sock *sk);
-static int MksckPageDescMMap(struct file *file,
- struct socket *sock,
- struct vm_area_struct *vma);
-static int MksckPageDescIoctl(struct socket *sock,
- unsigned int cmd,
- unsigned long arg);
-
-/**
- * @brief Delete a page descriptor container socket
- *
- * @param sock user socket structure
- * @return 0 on success, -errno on failure
- */
-static int
-MksckPageDescRelease(struct socket *sock)
-{
- /* This is generic socket release */
- struct sock *sk = sock->sk;
-
- if (sk) {
- lock_sock(sk);
- sock_orphan(sk);
- release_sock(sk);
- sock_put(sk);
- }
-
- sock->sk = NULL;
- sock->state = SS_FREE;
-
- return 0;
-}
-
-
-/**
- * Whenever a typed message is received from the monitor, we may choose to store
- * all the page descriptor content for a future mapping. One shall put a context
- * usable by host userland, that means trough a file descriptor, and as a secure
- * implementation we choose to define a strict set of operations that are used
- * only for that purpose. This set of operation is reduced to leaving the
- * default "PageDesc(s) accumulating" mode (inside ioctl), mapping the context,
- * and generic socket destruction.
- */
-static struct proto_ops mksckPageDescOps = {
- .family = AF_MKSCK,
- .owner = THIS_MODULE,
- .release = MksckPageDescRelease,
- .bind = sock_no_bind,
- .connect = sock_no_connect,
- .socketpair = sock_no_socketpair,
- .accept = sock_no_accept,
- .getname = sock_no_getname,
- .poll = sock_no_poll,
- .ioctl = MksckPageDescIoctl,
- .listen = sock_no_listen,
- .shutdown = sock_no_shutdown,
- .setsockopt = sock_no_setsockopt,
- .getsockopt = sock_no_getsockopt,
- .sendmsg = sock_no_sendmsg,
- .recvmsg = sock_no_recvmsg,
- .mmap = MksckPageDescMMap,
- .sendpage = sock_no_sendpage,
-};
-
-
-/**
- * @brief Create or accumulate to a PageDesc context, backed as a descriptor.
- *
- * @param sock user socket structure
- * @param msg user buffer to receive the file descriptor as ancillary data
- * @param pd source descriptor part of a message
- * @param pages pages count for this mapping
- *
- * @return error if negative, 0 otherwise
- *
- */
-static int
-MksckPageDescToFd(struct socket *sock,
- struct msghdr *msg,
- Mksck_PageDesc *pd,
- uint32 pages)
-{
- int retval;
- int newfd;
- struct socket *newsock;
- struct sock *newsk;
- struct sock *sk = sock->sk;
- MksckPageDescInfo **pmpdi, *mpdi;
- lock_sock(sk);
-
- /*
- * Relation between any mk socket and the PageDesc context is as follow:
- *
- * From the mk socket to the PageDesc context:
- * - sk->sk_user_data is a WEAK LINK, containing only a file descriptor
- * numerical value such that accumulating is keyed on it.
- *
- * From the PageDesc context to the mk socket:
- * - sk->sk_protinfo contains a MksckPageDescInfo struct.
- * - sk->sk_user_data is a pointer REF-COUNTED sock_hold() LINK, also it is
- * rarely dereferenced but usually used to check that the
- * right socket pair is used. Full dereferencing is used
- * only to break the described links.
- */
- if (sk->sk_user_data) {
- MksckPageDescInfo *mpdi2;
-
- /* continue any previous on-going mapping, i.e accumulate */
- newfd = *((int *)sk->sk_user_data);
- newsock = sockfd_lookup(newfd, &retval); // promote the weak link
- if (!newsock) {
- retval = -EINVAL;
- goto endProcessingReleaseSock;
- }
-
- newsk = newsock->sk;
- lock_sock(newsk);
- sockfd_put(newsock);
-
- if (((struct sock *)newsk->sk_user_data) != sk) {
- /* One way of going into this situation would be for userland to dup
- the file descriptor just received, close the original number, and
- open a new mk socket in the very same spot. The userland code have
- a lot of way of interacting with the kernel without this driver
- code to be notified. */
- retval = -EINVAL;
- release_sock(newsk);
- goto endProcessingReleaseSock;
- }
-
- mpdi = sock_kmalloc(newsk, sizeof(MksckPageDescInfo) +
- pages*sizeof(Mksck_PageDesc), GFP_KERNEL);
- if (IS_ERR(mpdi)) {
- retval = PTR_ERR(mpdi);
- release_sock(newsk);
- goto endProcessingReleaseSock;
- }
-
- /* There is no mandatory needs for us to notify userland from
- the progress in "appending" to the file descriptor, but it
- would feel strange if the userland would have no mean to
- tell if the received message was just not thrown away. So, in
- order to be consistent one fill the ancillary message while
- "creating" and "appending to" file descriptors. */
- retval = put_cmsg(msg, SOL_DECNET, 0, sizeof(int), &newfd);
- if (retval < 0) {
- goto endProcessingKFreeReleaseSock;
- }
-
- release_sock(sk);
-
- mpdi2 = (MksckPageDescInfo *)newsk->sk_protinfo;
- while (mpdi2->next) {
- mpdi2 = mpdi2->next;
- }
- pmpdi = &(mpdi2->next);
-
- } else {
- /* Create a new socket, new context and a new file descriptor. */
- retval = sock_create(sk->sk_family, sock->type, 0, &newsock);
- if (retval < 0) {
- goto endProcessingReleaseSock;
- }
-
- newsk = newsock->sk;
- lock_sock(newsk);
- newsk->sk_destruct = &MksckPageDescSkDestruct;
- newsk->sk_user_data = sk;
- sock_hold(sk); // keeps a reference to parent mk socket
- newsock->ops = &mksckPageDescOps;
-
- mpdi = sock_kmalloc(newsk, sizeof(MksckPageDescInfo) +
- pages*sizeof(Mksck_PageDesc), GFP_KERNEL);
- if (IS_ERR(mpdi)) {
- retval = PTR_ERR(mpdi);
- goto endProcessingFreeNewSock;
- }
-
- sk->sk_user_data = sock_kmalloc(sk, sizeof(int), GFP_KERNEL);
- if (IS_ERR(sk->sk_user_data)) {
- retval = PTR_ERR(sk->sk_user_data);
- sk->sk_user_data = NULL;
- goto endProcessingKFreeAndNewSock;
- }
-
- /* mapping to a file descriptor may fail if a thread is closing
- in parallel of sock_map_fd/sock_alloc_fd, or kernel memory is full */
- newfd = sock_map_fd(newsock, O_CLOEXEC);
- if (newfd < 0) {
- retval = newfd;
- sock_kfree_s(sk, sk->sk_user_data, sizeof(int));
- sk->sk_user_data = NULL;
- goto endProcessingKFreeAndNewSock;
- }
-
- /* notify userland from a new file descriptor, alike AF_UNIX ancillary */
- retval = put_cmsg(msg, SOL_DECNET, 0, sizeof(int), &newfd);
- if (retval < 0) {
- sock_kfree_s(sk, sk->sk_user_data, sizeof(int));
- sk->sk_user_data = NULL;
- sock_kfree_s(newsk, mpdi, sizeof(MksckPageDescInfo) +
- mpdi->pages*sizeof(Mksck_PageDesc));
- release_sock(newsk);
- sockfd_put(newsock);
- sock_release(newsock);
- put_unused_fd(newfd);
- goto endProcessingReleaseSock;
- }
-
- *(int*)sk->sk_user_data = newfd;
- release_sock(sk);
- pmpdi = (MksckPageDescInfo **)(&(newsk->sk_protinfo));
- }
-
- mpdi->next = NULL;
- mpdi->flags = 0;
- mpdi->mapCounts = 0;
- mpdi->pages = pages;
- memcpy(mpdi->descs, pd, pages*sizeof(Mksck_PageDesc));
-
- *pmpdi = mpdi; // link
- release_sock(newsk);
-
- /* increment all reference counters for the pages */
- MksckPageDescManage(pd, pages, MANAGE_INCREMENT);
- return 0;
-
-endProcessingKFreeAndNewSock:
- sock_kfree_s(newsk, mpdi, sizeof(MksckPageDescInfo) +
- mpdi->pages*sizeof(Mksck_PageDesc));
-endProcessingFreeNewSock:
- release_sock(newsk);
- sock_release(newsock);
- release_sock(sk);
- return retval;
-
-endProcessingKFreeReleaseSock:
- sock_kfree_s(newsk, mpdi, sizeof(MksckPageDescInfo) +
- mpdi->pages*sizeof(Mksck_PageDesc));
- release_sock(newsk);
-endProcessingReleaseSock:
- release_sock(sk);
- return retval;
-}
-
-/**
- * @brief Callback at socket destruction
- *
- * @param sk pointer to kernel socket structure
- */
-static void
-MksckPageDescSkDestruct(struct sock *sk)
-{
- struct sock *mkSk = NULL;
- MksckPageDescInfo *mpdi;
- lock_sock(sk);
- mpdi = sk->sk_protinfo;
- while (mpdi) {
- MksckPageDescInfo *next = mpdi->next;
- MksckPageDescManage(mpdi->descs, mpdi->pages,
- MANAGE_DECREMENT);
- sock_kfree_s(sk, mpdi, sizeof(MksckPageDescInfo) +
- mpdi->pages*sizeof(Mksck_PageDesc));
- mpdi = next;
- }
- if (sk->sk_user_data) {
- mkSk = (struct sock *)sk->sk_user_data;
- sk->sk_user_data = NULL;
- }
- sk->sk_protinfo = NULL;
- release_sock(sk);
- /* clean the monki socket that we are holding */
- if (mkSk) {
- lock_sock(mkSk);
- sock_kfree_s(mkSk, mkSk->sk_user_data, sizeof(int));
- mkSk->sk_user_data = NULL;
- release_sock(mkSk);
- sock_put(mkSk); // revert of sock_hold()
- }
-}
-
-/**
- * @brief The mmap operation of the PageDesc context file descriptor.
- *
- * The mmap command is used to mmap any detached (i.e. no more accumulating)
- * PageDesc context, full of the content from its parent communication mk
- * socket. Mapping may be done a specified number of times, so that the
- * PageDesc context could become useless (as a security restriction).
- *
- * Also note that mapping from an offset different from zero is considered
- * as a userland invalid operation.
- *
- * @param file user file structure
- * @param sock user socket structure
- * @param vma virtual memory area structure
- *
- * @return error code, 0 on success
- */
-static int
-MksckPageDescMMap(struct file *file,
- struct socket *sock,
- struct vm_area_struct *vma)
-{
- struct sock *sk = sock->sk;
- MksckPageDescInfo *mpdi;
- struct iovec iov;
- unsigned long vm_flags;
- int freed = 0;
-
- iov.iov_base = (void*)vma->vm_start;
- iov.iov_len = vma->vm_end - vma->vm_start;
-
- lock_sock(sk);
- mpdi = sk->sk_protinfo;
-
- // vma->vm_pgoff is checked, since offsetting the map is not supported
- if (!mpdi || sk->sk_user_data || vma->vm_pgoff) {
- release_sock(sk);
- printk(KERN_INFO "MMAP failed for virt %lx size %lx\n",
- vma->vm_start, vma->vm_end - vma->vm_start);
- return -EINVAL;
- }
-
- vm_flags = mpdi->flags;
- if ((vma->vm_flags & ~vm_flags) & (VM_READ|VM_WRITE)) {
- release_sock(sk);
- return -EACCES;
- }
-
- while (mpdi) {
- MksckPageDescInfo *next = mpdi->next;
- MksckPageDescMap(mpdi->descs, mpdi->pages, &iov, 1, vma);
- if (mpdi->mapCounts && !--mpdi->mapCounts) {
- MksckPageDescManage(mpdi->descs, mpdi->pages,
- MANAGE_DECREMENT);
- sock_kfree_s(sk, mpdi, sizeof(MksckPageDescInfo) +
- mpdi->pages*sizeof(Mksck_PageDesc));
- freed = 1;
- }
- mpdi = next;
- }
-
- if (freed) {
- sk->sk_protinfo = NULL;
- }
- vma->vm_ops = &mksckVMOps;
- release_sock(sk);
- return 0;
-}
-
-/**
- * @brief The ioctl operation of the PageDesc context file descriptor.
- *
- * The ioctl MKSCK_DETACH command is used to detach the PageDesc context
- * from its parent communication mk socket. Once done, the context
- * is able to remap the transferred PageDesc(s) of typed messages accumulated
- * into the context.
- *
- * @param sock user socket structure
- * @param cmd select which cmd function needs to be performed
- * @param arg argument for command
- *
- * @return error code, 0 on success
- */
-static int
-MksckPageDescIoctl(struct socket *sock,
- unsigned int cmd,
- unsigned long arg)
-{
- struct sock *monkiSk = NULL;
- struct sock *sk = sock->sk;
- MksckPageDescInfo *mpdi;
- int retval = 0;
-
- switch (cmd) {
- /**
- * ioctl MKSCK_DETACH (in and out):
- * Detach, compute size and define allowed protection access rights
- *
- * [in]: unsigned long flags, similar to prot argument of mmap()
- * unsigned long number of available further mappings
- * with 0 meaning unlimited number of mappings
- * [out]: unsigned long size of the available mappable area
- */
- case MKSCK_DETACH: {
- unsigned long ul[2];
- lock_sock(sk);
- mpdi = sk->sk_protinfo;
- // read unsigned long argument that contains the mmap alike flags
- if (copy_from_user(ul, (void *)arg, sizeof ul)) {
- retval = -EFAULT;
- // check that the file descriptor has a parent and some context there
- } else if (!mpdi || !sk->sk_user_data) {
- retval = -EINVAL;
- } else {
- /* compute mapping protection bits from argument and size of the
- * mapping, that is also given back to userland as unsigned long.
- */
- uint32 flags = calc_vm_prot_bits(ul[0]);
- ul[0] = 0;
- while (mpdi) {
- MksckPageDescInfo *next = mpdi->next;
- ul[0] += MksckPageDescManage(mpdi->descs, mpdi->pages,
- MANAGE_COUNT);
- mpdi->mapCounts = ul[1];
- mpdi = next;
- }
- if (copy_to_user((void *)arg, ul, sizeof(ul[0]))) {
- retval = -EFAULT;
- } else {
- mpdi = sk->sk_protinfo;
- mpdi->flags = flags;
- monkiSk = (struct sock *)sk->sk_user_data;
- sk->sk_user_data = NULL;
- }
- }
- release_sock(sk);
- // clean the monki socket that we are holding
- if ((sk = monkiSk)) {
- lock_sock(sk);
- sock_kfree_s(sk, sk->sk_user_data, sizeof(int));
- sk->sk_user_data = NULL;
- release_sock(sk);
- sock_put(sk);
- }
- break;
- }
- default: {
- retval = -EINVAL;
- break;
- }
- }
- return retval;
-}
-
-
-/**
- * @brief VMX receiving a packet from VMM.
- *
- * @param kiocb kernel io control block (unused)
- * @param sock user socket structure
- * @param msg user buffer to receive the packet
- * @param len size of the user buffer
- * @param flags flags
- *
- * @return -errno on failure, else length of untyped portion + total number
- * of bytes mapped for typed portion.
- */
-static int
-MksckDgramRecvMsg(struct kiocb *kiocb,
- struct socket *sock,
- struct msghdr *msg,
- size_t len,
- int flags)
-{
- int err = 0;
- struct sock *sk = sock->sk;
- Mksck *mksck;
- Mksck_Datagram *dg;
- struct sockaddr_mk *fromAddr;
- uint32 read;
- struct iovec *iov;
- size_t payloadLen, untypedLen;
- uint32 iovCount;
-
- if (flags & MSG_OOB || flags & MSG_ERRQUEUE) {
- return -EOPNOTSUPP;
- }
-
- if ((msg->msg_name != NULL) && (msg->msg_namelen < sizeof *fromAddr)) {
- return -EINVAL;
- }
-
- lock_sock(sk);
- if ((err = MksckTryBind(sk))) {
- release_sock(sk);
- return err;
- }
- mksck = sk->sk_protinfo;
-
- /*
- * To avoid mksck disappearing right after the release_sock the
- * refcount needs to be incremented. For more details read the
- * block comment on locking in MksckCreate.
- */
- ATOMIC_ADDV(mksck->refCount, 1);
- release_sock(sk);
-
- /*
- * Get pointer to next packet in ring to be dequeued.
- */
- while (1) {
-
- /*
- * Wait to make sure this is the only thread trying to access socket.
- */
- if ((err = Mutex_Lock(&mksck->mutex, MutexModeEX)) < 0) {
- goto decRefc;
- }
-
- /*
- * See if packet in ring.
- */
- read = mksck->read;
- if (read != mksck->write) {
- break;
- }
-
- /*
- * Nothing there, if user wants us not to block then just return EAGAIN.
- */
- if (flags & MSG_DONTWAIT) {
- Mutex_Unlock(&mksck->mutex, MutexModeEX);
- err = -EAGAIN;
- goto decRefc;
- }
-
- /*
- * Nothing there, unlock socket and wait for data.
- */
- mksck->foundEmpty ++;
- err = Mutex_UnlSleep(&mksck->mutex, MutexModeEX, MKSCK_CVAR_FILL);
- if (err < 0) {
- PRINTK(KERN_INFO "MksckDgramRecvMsg: aborted\n");
- goto decRefc;
- }
- }
-
- /*
- * Point to packet in ring.
- */
- dg = (void *)&mksck->buff[read];
-
- /*
- * Provide the address of the sender.
- */
- if (msg->msg_name != NULL) {
- fromAddr = (void *)msg->msg_name;
- fromAddr->mk_addr = dg->fromAddr;
- fromAddr->mk_family = AF_MKSCK;
- msg->msg_namelen = sizeof *fromAddr;
- } else {
- msg->msg_namelen = 0;
- }
-
- /*
- * Copy data from ring buffer to caller's buffer and remove packet from
- * ring buffer.
- */
- iov = msg->msg_iov;
- iovCount = msg->msg_iovlen;
- payloadLen = untypedLen =
- dg->len - dg->pages * sizeof(Mksck_PageDesc) - dg->pad;
-
- /*
- * Handle the untyped portion of the message.
- */
- if (untypedLen <= len) {
- err = memcpy_toiovec(iov,
- dg->data,
- untypedLen);
- if (err < 0) {
- printk("MksckDgramRecvMsg: Failed to memcpy_to_iovec untyped message component "
- "(buf len %d datagram len %d (untyped %d))\n",
- len,
- dg->len,
- untypedLen);
- }
- } else {
- err = -EINVAL;
- }
-
- /*
- * Map in the typed descriptor.
- */
- if (err >= 0 && dg->pages > 0) {
- Mksck_PageDesc *pd = (Mksck_PageDesc *)(dg->data + untypedLen + dg->pad);
-
- /*
- * There are 3 ways of receiving typed messages from the monitor.
- * - The typed message is mapped directly into a VMA. To indicate this the
- * userland sets msg_controllen == 0.
- * - The typed message is mapped directly into a VMA and a file descriptor
- * created for further mappings on the host (in same userland address
- * space or an alternate userland address space). In this case
- * msg_controllen should be set to sizeof(fd).
- * - The typed message is not mapped directly into a VMA, but a file
- * descriptor is created for later mapping on the host. In this case
- * msg_controllen should be set to sizeof(fd) and the supplied iovec
- * shall not specify a receive window.
- *
- * The conjuncts below decide on which of these 3 cases we've encountered.
- */
-
- if ((msg->msg_controllen <= 0) ||
- ((err = MksckPageDescToFd(sock, msg, pd, dg->pages)) != 0) ||
- (MsgHdrHasAvailableRoom(msg) != 0)) {
-
- down_write(&current->mm->mmap_sem); // lock for a change of mapping
- payloadLen += MksckPageDescMap(pd, dg->pages, iov, iovCount, NULL);
- up_write(&current->mm->mmap_sem);
- }
- }
-
- /*
- * Now that packet is removed, it is safe to unlock socket so another thread
- * can do a recv(). We also want to wake someone waiting for room to insert
- * a new packet.
- */
- if ((err >= 0) && Mksck_IncReadIndex(mksck, read, dg)) {
- Mutex_UnlWake(&mksck->mutex, MutexModeEX, MKSCK_CVAR_ROOM, true);
- } else {
- Mutex_Unlock(&mksck->mutex, MutexModeEX);
- }
-
- /*
- * If memcpy error, return error status.
- * Otherwise, return number of bytes copied.
- */
- if (err >= 0) {
- err = payloadLen;
- }
-
-decRefc:
- Mksck_DecRefc(mksck);
- return err;
-}
-
-
-/**
- * @brief VMX sending a packet to VMM.
- *
- * @param kiocb kernel io control block
- * @param sock user socket structure
- * @param msg packet to be transmitted
- * @param len length of the packet
- *
- * @return length of the sent msg on success, -errno on failure
- */
-static int
-MksckDgramSendMsg(struct kiocb *kiocb,
- struct socket *sock,
- struct msghdr *msg,
- size_t len)
-{
- int err = 0;
- struct sock *sk = sock->sk;
- Mksck *peerMksck;
- Mksck_Datagram *dg;
- uint32 needed;
- uint32 write;
- Mksck_Address fromAddr;
-
- if (msg->msg_flags & MSG_OOB) {
- return -EOPNOTSUPP;
- }
-
- if (len > MKSCK_XFER_MAX) {
- return -EMSGSIZE;
- }
-
- /*
- * In the next locked section peerMksck pointer needs to be set and
- * its refcount needs to be incremented.
- */
- lock_sock(sk);
- do {
- Mksck *mksck;
- Mksck_Address peerAddr =
- { .addr = (msg->msg_name ?
- ((struct sockaddr_mk *)msg->msg_name)->mk_addr.addr :
- MKSCK_ADDR_UNDEF) };
-
- if ((err = MksckTryBind(sk))) {
- break;
- }
- mksck = sk->sk_protinfo;
- fromAddr = mksck->addr;
-
- /*
- * If the socket is connected, use that address (no sendto for
- * connected sockets). Otherwise, use the provided address if any.
- */
- if ((peerMksck = mksck->peer)) {
- if (peerAddr.addr != MKSCK_ADDR_UNDEF &&
- peerAddr.addr != mksck->peerAddr.addr) {
- err = -EISCONN;
- break;
- }
- /*
- * To avoid mksckPeer disappearing right after the
- * release_sock the refcount needs to be incremented. For
- * more details read the block comment on locking in
- * MksckCreate.
- */
- ATOMIC_ADDV(peerMksck->refCount, 1);
- } else if (peerAddr.addr == MKSCK_ADDR_UNDEF) {
- err = -ENOTCONN;
- } else {
- /*
- * LockPeer also increments the refc on the peer.
- */
- err = LockPeer(peerAddr, &peerMksck);
- }
- } while(0);
- release_sock(sk);
-
- if (err) {
- return err;
- }
-
- /*
- * Get pointer to sufficient empty space in ring buffer.
- */
- needed = MKSCK_DGSIZE(len);
- while (1) {
- /*
- * Wait to make sure this is the only thread trying to write to ring.
- */
- if ((err = Mutex_Lock(&peerMksck->mutex, MutexModeEX)) < 0) {
- goto decRefc;
- }
-
- /*
- * Check if socket can receive data.
- */
- if (peerMksck->shutDown & MKSCK_SHUT_RD) {
- err = -ENOTCONN;
- goto unlockDecRefc;
- }
-
- /*
- * See if there is room for the packet.
- */
- write = Mksck_FindSendRoom(peerMksck, needed);
- if (write != MKSCK_FINDSENDROOM_FULL) {
- break;
- }
-
- /*
- * No room, unlock socket and maybe wait for room.
- */
- if (msg->msg_flags & MSG_DONTWAIT) {
- err = -EAGAIN;
- goto unlockDecRefc;
- }
-
- peerMksck->foundFull ++;
- err = Mutex_UnlSleep(&peerMksck->mutex,
- MutexModeEX,
- MKSCK_CVAR_ROOM);
- if (err < 0) {
- PRINTK(KERN_INFO "MksckDgramSendMsg: aborted\n");
- goto decRefc;
- }
- }
-
- /*
- * Point to room in ring and fill in message.
- */
- dg = (void *)&peerMksck->buff[write];
-
- dg->fromAddr = fromAddr;
- dg->len = len;
-
- if ((err = memcpy_fromiovec(dg->data, msg->msg_iov, len)) != 0) {
- goto unlockDecRefc;
- }
-
- /*
- * Increment past message.
- */
- Mksck_IncWriteIndex(peerMksck, write, needed);
-
- /*
- * Unlock socket and wake someone trying to receive, ie, we filled
- * in a message.
- */
- Mutex_UnlWake(&peerMksck->mutex, MutexModeEX, MKSCK_CVAR_FILL, false);
-
- /*
- * Maybe guest is in a general 'wait for interrupt' wait or
- * grinding away executing guest instructions.
- *
- * If it has a receive callback armed for the socket and is
- * waiting a message, just wake it up. Else send an IPI to the CPU
- * running the guest so it will interrupt whatever it is doing and
- * read the message.
- *
- * Holding the mksckPage->mutex prevents mksckPage->vmHKVA from
- * clearing on us.
- */
- if (peerMksck->rcvCBEntryMVA != 0) {
- MksckPage *peerMksckPage = Mksck_ToSharedPage(peerMksck);
-
- if ((err = Mutex_Lock(&peerMksckPage->mutex, MutexModeSH)) == 0) {
- uint32 sockIdx = peerMksck->index;
- MvpkmVM *vm = (MvpkmVM *) peerMksckPage->vmHKVA;
-
- /*
- * The destruction of vm and wsp is blocked by the
- * mksckPage->mutex.
- */
- if (vm) {
- WorldSwitchPage *wsp = vm->wsp;
-
- ASSERT(sockIdx < 8 * sizeof peerMksckPage->wakeVMMRecv);
- ATOMIC_ORV(peerMksckPage->wakeVMMRecv, 1U << sockIdx);
-
- if (wsp) {
- Mvpkm_WakeGuest(vm, ACTION_MKSCK);
- }
- }
- Mutex_Unlock(&peerMksckPage->mutex, MutexModeSH);
- }
- }
-
- /*
- * If all are happy tell the caller the number of transferred bytes.
- */
- if (!err) {
- err = len;
- }
-
- /*
- * Now that we are done with target socket, allow it to be freed.
- */
-decRefc:
- Mksck_DecRefc(peerMksck);
- return err;
-
-unlockDecRefc:
- Mutex_Unlock(&peerMksck->mutex, MutexModeEX);
- goto decRefc;
-}
-
-
-/**
- * @brief Page fault handler for receive windows. Since the host process
- * should not be faulting in this region and only be accessing
- * memory that has been established via a typed message transfer,
- * we always signal the fault back to the process.
- */
-static int
-MksckFault(struct vm_area_struct *vma, struct vm_fault *vmf)
-{
- return VM_FAULT_SIGBUS;
-}
-
-/**
- * @brief Establish a region in the host process suitable for use as a
- * receive window.
- *
- * @param file file reference (ignored).
- * @param sock user socket structure.
- * @param vma Linux virtual memory area defining the region.
- *
- * @return 0 on success, otherwise error code.
- */
-static int
-MksckMMap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
-{
- /*
- * All the hard work is done in MksckDgramRecvMsg. Here we simply mark the
- * vma as belonging to Mksck.
- */
- vma->vm_ops = &mksckVMOps;
-
- return 0;
-}
-
-/**
- * @brief This gets called after returning from the monitor.
- * Since the monitor doesn't directly wake VMX threads when it sends
- * something to VMX (for efficiency), this routine checks for the
- * omitted wakes and does them.
- * @param mksckPage some shared page that the monitor writes packets to, ie
- * an host shared page
- */
-void
-Mksck_WakeBlockedSockets(MksckPage *mksckPage)
-{
- Mksck *mksck;
- uint32 i, wakeHostRecv;
-
- wakeHostRecv = mksckPage->wakeHostRecv;
- if (wakeHostRecv != 0) {
- mksckPage->wakeHostRecv = 0;
- for (i = 0; wakeHostRecv != 0; i ++) {
- if (wakeHostRecv & 1) {
- mksck = &mksckPage->sockets[i];
- Mutex_CondSig(&mksck->mutex, MKSCK_CVAR_FILL, true);
- }
- wakeHostRecv >>= 1;
- }
- }
-}
-
-/**
- * @brief allocate and initialize a shared page.
- * @return pointer to shared page.<br>
- * NULL on error
- */
-MksckPage *
-MksckPageAlloc(void)
-{
- uint32 jj;
- /*
- * Ask for pages in the virtual kernel space. There is no
- * requirement to be physically contiguous.
- */
- MksckPage *mksckPage = vmalloc(MKSCKPAGE_SIZE);
-
- if (mksckPage) {
-
- /*
- * Initialize its contents. Start refCount at 1 and decrement it
- * when the worldswitch or VM page gets freed.
- */
- memset(mksckPage, 0, MKSCKPAGE_SIZE);
- ATOMIC_SETV(mksckPage->refCount, 1);
- mksckPage->portStore = MKSCK_PORT_HIGH;
-
- Mutex_Init(&mksckPage->mutex);
- for (jj = 0; jj<MKSCK_SOCKETS_PER_PAGE; jj++) {
- Mutex_Init(&mksckPage->sockets[jj].mutex);
- }
- }
-
- return mksckPage;
-}
-
-/**
- * @brief Release the allocated pages.
- * @param mksckPage the address of the mksckPage to be released
- */
-static void
-MksckPageRelease(MksckPage *mksckPage)
-{
- int ii;
-
- for (ii = 0; ii<MKSCK_SOCKETS_PER_PAGE; ii++) {
- Mutex_Destroy(&mksckPage->sockets[ii].mutex);
- }
- Mutex_Destroy(&mksckPage->mutex);
-
- vfree(mksckPage);
-}
-
-/**
- * @brief Using the tgid locate the vmid of this process.
- * Assumed that mksckPageListLock is held
- * @return the vmId if page is already allocated,
- * the first vacant vmid if not yet allocated.<br>
- * MKSCK_PORT_UNDEF if no slot is vacant
- */
-static inline Mksck_VmId
-GetHostVmId(void)
-{
- uint32 jj;
- Mksck_VmId vmId, vmIdFirstVacant = MKSCK_VMID_UNDEF;
- MksckPage *mksckPage;
- uint32 tgid = task_tgid_vnr(current);
- /*
- * Assign an unique vmId to the shared page. Start the search from
- * the vmId that is the result of hashing tgid to 15 bits. As a
- * used page with a given vmId can occupy only a given slot in the
- * mksckPages array, it is enough to search through the
- * MKSCK_MAX_SHARES slots for a vacancy.
- */
- for (jj = 0, vmId = MKSCK_TGID2VMID(tgid);
- jj < MKSCK_MAX_SHARES;
- jj++, vmId++) {
- if (vmId > MKSCK_VMID_HIGH) {
- vmId = 0;
- }
- mksckPage = mksckPages[MKSCK_VMID2IDX(vmId)];
-
- if (mksckPage) {
- if (mksckPage->tgid == tgid &&
- !mksckPage->isGuest) {
- return mksckPage->vmId;
- }
-
- } else if (vmIdFirstVacant == MKSCK_VMID_UNDEF) {
- vmIdFirstVacant = vmId;
- }
- }
- return vmIdFirstVacant;
-}
-
-
-/**
- * @brief Locate the first empty slot
- * Assumed that mksckPageListLock is held
- * @return the first vacant vmid.<br>
- * MKSCK_PORT_UNDEF if no slot is vacant
- */
-static inline Mksck_VmId
-GetNewGuestVmId(void)
-{
- Mksck_VmId vmId;
-
- for (vmId = 0; vmId < MKSCK_MAX_SHARES; vmId++) {
- if (!mksckPages[MKSCK_VMID2IDX(vmId)]) {
- return vmId;
- }
- }
- return MKSCK_VMID_UNDEF;
-}
-
-
-/**
- * @brief Find shared page for a given idx. The page referred to be the
- * idx should exist and be locked by the caller.
- * @param idx index of the page in the array
- * @return pointer to shared page
- */
-MksckPage *
-MksckPage_GetFromIdx(uint32 idx)
-{
- MksckPage *mksckPage = mksckPages[idx];
- ASSERT(mksckPage);
- ASSERT(idx<MKSCK_MAX_SHARES);
- ASSERT(ATOMIC_GETO(mksckPage->refCount));
- return mksckPage;
-}
-
-/**
- * @brief find shared page for a given vmId
- * The vmid should exist and be locked by the caller.
- * @param vmId vmId to look for, either an host vmId or a guest vmId
- * @return pointer to shared page
- */
-MksckPage *
-MksckPage_GetFromVmId(Mksck_VmId vmId)
-{
- MksckPage *mksckPage = mksckPages[MKSCK_VMID2IDX(vmId)];
- ASSERT(mksckPage);
- ASSERT(mksckPage->vmId == vmId);
- ASSERT(ATOMIC_GETO(mksckPage->refCount));
- return mksckPage;
-}
-
-
-/**
- * @brief find shared page for a given vmId
- * @param vmId vmId to look for, either an host vmId or a guest vmId
- * @return NULL: no such shared page exists<br>
- * else: pointer to shared page.
- * Call Mksck_DecRefc() when done with pointer
- */
-MksckPage *
-MksckPage_GetFromVmIdIncRefc(Mksck_VmId vmId)
-{
- MksckPage *mksckPage;
-
- spin_lock(&mksckPageListLock);
- mksckPage = mksckPages[MKSCK_VMID2IDX(vmId)];
-
- if (!mksckPage || (mksckPage->vmId != vmId)) {
- printk(KERN_INFO "MksckPage_GetFromVmIdIncRefc: vmId %04X not found\n",
- vmId);
- mksckPage = NULL;
- } else {
- ATOMIC_ADDV(mksckPage->refCount, 1);
- }
- spin_unlock(&mksckPageListLock);
- return mksckPage;
-}
-
-
-/**
- * @brief find or allocate shared page using tgid
- * @return NULL: no such shared page exists<br>
- * else: pointer to shared page.
- * Call Mksck_DecRefc() when done with pointer
- */
-MksckPage *
-MksckPage_GetFromTgidIncRefc(void)
-{
- MksckPage *mksckPage;
- Mksck_VmId vmId;
-
- while (1) {
- spin_lock(&mksckPageListLock);
- vmId = GetHostVmId();
-
- if (vmId == MKSCK_VMID_UNDEF) {
- /*
- * No vmId has been allocated yet and there is no free slot.
- */
- spin_unlock(&mksckPageListLock);
- return NULL;
- }
-
- mksckPage = mksckPages[MKSCK_VMID2IDX(vmId)];
- if (mksckPage != NULL) {
- /*
- * There is a vmid already allocated, increment the refc on it.
- */
- ATOMIC_ADDV(mksckPage->refCount, 1);
- spin_unlock(&mksckPageListLock);
- return mksckPage;
- }
-
- /*
- * Have to release spinlock to allocate a new page.
- */
- spin_unlock(&mksckPageListLock);
- mksckPage = MksckPageAlloc();
- if (mksckPage == NULL) {
- return NULL;
- }
-
- /*
- * Re-lock and make sure no one else allocated while unlocked.
- * If someone else did allocate, free ours off and use theirs.
- */
- spin_lock(&mksckPageListLock);
- vmId = GetHostVmId();
- if ((vmId != MKSCK_VMID_UNDEF) &&
- (mksckPages[MKSCK_VMID2IDX(vmId)] == NULL)) {
- break;
- }
- spin_unlock(&mksckPageListLock);
- MksckPageRelease(mksckPage);
- }
-
- /*
- * This is a successful new allocation. insert it into the table
- * and initialize the fields.
- */
- mksckPages[MKSCK_VMID2IDX(vmId)] = mksckPage;
- mksckPage->vmId = vmId;
- mksckPage->isGuest = false;
- mksckPage->vmHKVA = 0;
- mksckPage->tgid = task_tgid_vnr(current);
- printk(KERN_DEBUG "New host mksck page is allocated: idx %x, vmId %x, tgid %d\n",
- MKSCK_VMID2IDX(vmId), vmId, mksckPage->tgid);
-
- spin_unlock(&mksckPageListLock);
- return mksckPage;
-}
-
-/**
- * @brief Initialize the VMX provided wsp. Allocate communication page.
- * @param vm which virtual machine we're running
- * @return 0 if all OK, error value otherwise
- */
-int
-Mksck_WspInitialize(MvpkmVM *vm)
-{
- WorldSwitchPage *wsp = vm->wsp;
- int err;
- Mksck_VmId vmId;
- MksckPage *mksckPage;
-
- if (wsp->guestId) {
- err = -EBUSY;
- } else if (!(mksckPage = MksckPageAlloc())) {
- err = -ENOMEM;
- } else {
- spin_lock(&mksckPageListLock);
-
- if ((vmId = GetNewGuestVmId()) == MKSCK_VMID_UNDEF) {
-
- err = -EMFILE;
- MksckPageRelease(mksckPage);
-
- printk(KERN_INFO "Mksck_WspInitialize: Cannot allocate vmId\n");
-
- } else {
- /*
- * Now that the mksckPage is all initialized, let others see it.
- */
- mksckPages[MKSCK_VMID2IDX(vmId)] = mksckPage;
- mksckPage->vmId = vmId;
- mksckPage->isGuest = true;
- mksckPage->vmHKVA = (HKVA)vm;
- /* mksckPage->tgid is undefined when isGuest is true */
-
- wsp->guestId = vmId;
-
- printk(KERN_DEBUG "New guest mksck page is allocated: idx %x, vmId %x\n",
- MKSCK_VMID2IDX(vmId), vmId);
-
- err = 0;
- }
-
- /*
- * All stable, ie, mksckPages[] written, ok to unlock now.
- */
- spin_unlock(&mksckPageListLock);
- }
-
- return err;
-}
-
-/**
- * @brief Release the wsp. Clean up after the monitor. Free the
- * associated communication page.
- * @param wsp which worldswitch page (VCPU)
- */
-void
-Mksck_WspRelease(WorldSwitchPage *wsp)
-{
- int ii;
- int err;
- MksckPage *mksckPage = MksckPage_GetFromVmId(wsp->guestId);
-
- /*
- * The worldswitch page for a particular VCPU is about to be freed
- * off, so we know the monitor will never execute again. But the
- * monitor most likely left some sockets open. Those may have
- * outbound connections to host sockets that we must close.
- *
- * Loop through all possibly open sockets.
- */
- uint32 isOpened = wsp->isOpened;
- Mksck *mksck = mksckPage->sockets;
- while (isOpened) {
- if (isOpened & 1) {
- ASSERT(ATOMIC_GETO(mksck->refCount) != 0);
- /*
- * The socket may be connected to a peer (host) socket, so we
- * have to decrement that target socket's reference
- * count. Unfortunately, Mksck_DisconnectPeer(mksck) cannot
- * be called as mksck->peer is an mva not an hkva. Translate
- * the address first.
- */
- if (mksck->peer) {
- MksckPage *mksckPagePeer = MksckPage_GetFromVmId(mksck->peerAddr.vmId);
- ASSERT(mksckPagePeer);
- mksck->peer = MksckPage_GetFromAddr(mksckPagePeer, mksck->peerAddr);
- ASSERT(mksck->peer);
- /* mksck->peer is now a hkva */
- }
-
- Mksck_CloseCommon(mksck);
- }
- isOpened >>= 1;
- mksck++;
- }
-
- /*
- * A host socket may be in the process of sending to the guest. It
- * will attempt to wake up the guest using mksckPage->vmHKVA and
- * mksckPage->vmHKVA->wsp. To assure that the vm and wsp structures
- * are not disappearing from under the sending thread we lock the
- * page here.
- */
- err = Mutex_Lock(&mksckPage->mutex, MutexModeEX);
- ASSERT(!err);
- mksckPage->vmHKVA = 0;
- Mutex_Unlock(&mksckPage->mutex, MutexModeEX);
- /*
- * Decrement refcount set by MksckPageAlloc() call in
- * Mksck_WspInitialize().
- */
- MksckPage_DecRefc(mksckPage);
-
- /*
- * Decrement refcount set by VMM:Mksck_Init() referring to the local
- * variable guestMksckPage.
- */
- if (wsp->guestPageMapped) {
- wsp->guestPageMapped = false;
- MksckPage_DecRefc(mksckPage);
- }
-
- /*
- * Another task is to decrement the reference count on the mksck
- * pages the monitor accessed. Those pages are listed in the
- * wsp->isPageMapped list. They were locked by the monitor
- * calling WSCALL_GET_PAGE_FROM_VMID
- */
- for (ii = 0; ii < MKSCK_MAX_SHARES; ii++) {
- if (wsp->isPageMapped[ii]) {
- MksckPage *mksckPageOther = MksckPage_GetFromIdx(ii);
-
- wsp->isPageMapped[ii] = false;
- MksckPage_DecRefc(mksckPageOther);
- }
- }
-}
-
-/**
- * @brief disconnect from peer by decrementing
- * peer socket's reference count and clearing the pointer.
- * @param mksck local socket to check for connection
- */
-void
-Mksck_DisconnectPeer(Mksck *mksck)
-{
- Mksck *peerMksck = mksck->peer;
- if (peerMksck != NULL) {
- mksck->peer = NULL;
- mksck->peerAddr.addr = MKSCK_ADDR_UNDEF;
- Mksck_DecRefc(peerMksck);
- }
-}
-
-
-/**
- * @brief decrement shared page reference count, free page if it goes zero.
- * also do a dmb first to make sure all activity on the struct is
- * finished before decrementing the ref count.
- * @param mksckPage shared page
- */
-void
-MksckPage_DecRefc(MksckPage *mksckPage)
-{
- uint32 oldRefc;
-
- DMB();
- do {
- while ((oldRefc = ATOMIC_GETO(mksckPage->refCount)) == 1) {
-
- /*
- * Find corresponding entry in list of known shared pages and
- * clear it so we can't open any new sockets on this shared
- * page, thus preventing its refCount from being incremented.
- */
- spin_lock(&mksckPageListLock);
- if (ATOMIC_SETIF(mksckPage->refCount, 0, 1)) {
- uint32 ii = MKSCK_VMID2IDX(mksckPage->vmId);
- ASSERT(ii < MKSCK_MAX_SHARES);
- ASSERT(mksckPages[ii] == mksckPage);
- mksckPages[ii] = NULL;
- spin_unlock(&mksckPageListLock);
- printk(KERN_DEBUG "%s mksck page is released: idx %x, vmId %x, tgid %d\n",
- mksckPage->isGuest?"Guest":"Host",
- ii, mksckPage->vmId, mksckPage->tgid);
- MksckPageRelease(mksckPage);
- return;
- }
- spin_unlock(&mksckPageListLock);
- }
- ASSERT(oldRefc != 0);
- } while (!ATOMIC_SETIF(mksckPage->refCount, oldRefc - 1, oldRefc));
-}
-
-/**
- * @brief Lookup if the provided mpn belongs to one of the Mksck pages. Map if found.
- * @return 0 if all OK, error value otherwise
- */
-int
-MksckPage_LookupAndInsertPage(struct vm_area_struct *vma,
- unsigned long address,
- MPN mpn)
-{
- int ii, jj;
- MksckPage **mksckPagePtr = mksckPages;
-
- spin_lock(&mksckPageListLock);
- for (jj = MKSCK_MAX_SHARES; jj--; mksckPagePtr++) {
- if (*mksckPagePtr) {
- for (ii = 0; ii < MKSCKPAGE_TOTAL; ii++) {
- if (vmalloc_to_pfn((void*)(((HKVA)*mksckPagePtr) + ii*PAGE_SIZE)) == mpn &&
- vm_insert_page(vma, address, pfn_to_page(mpn)) == 0) {
- spin_unlock(&mksckPageListLock);
- return 0;
- }
- }
- }
- }
- spin_unlock(&mksckPageListLock);
- return -1;
-}
-
-
-/**
- * @brief Print information on the allocated shared pages
- *
- * This function reports (among many other things) on the use of locks
- * on the mksck page (page lock and individual socket locks). To avoid
- * the Hiesenberg effect it avoids using locks unless there is a
- * danger of dereferencing freed memory. In particular, holding
- * mksckPageListLock ensures that the mksck page is not freed while it
- * is read. But under very rare conditions this function may report
- * inconsistent or garbage data.
- */
-static int
-MksckPageInfoShow(struct seq_file *m, void *private)
-{
- int ii, jj;
- uint32 isPageMapped = 0;
- int err;
- MvpkmVM *vm;
-
- /*
- * Lock is needed to atomize the test and dereference of
- * mksckPages[ii]
- */
- spin_lock(&mksckPageListLock);
- for (ii = 0; ii < MKSCK_MAX_SHARES; ii++) {
- MksckPage *mksckPage = mksckPages[ii];
- if (mksckPage != NULL && mksckPage->isGuest) {
- /*
- * After the refcount is incremented mksckPage will not be
- * freed and it can continued to be dereferenced after the
- * unlock of mksckPageListLock.
- */
- ATOMIC_ADDV(mksckPage->refCount, 1);
- spin_unlock(&mksckPageListLock);
-
- /*
- * To dereference mksckPage->vmHKVA, we need to have the page
- * lock.
- */
- err = Mutex_Lock(&mksckPage->mutex, MutexModeEX);
- vm = (MvpkmVM *) mksckPage->vmHKVA;
-
- if (err == 0 && vm && vm->wsp) {
- for (jj = 0; jj < MKSCK_MAX_SHARES; jj++) {
- if (vm->wsp->isPageMapped[jj]) isPageMapped |= 1<<jj;
- }
- }
- Mutex_Unlock(&mksckPage->mutex, MutexModeEX);
- /*
- * Decrement the page refcount and relock the
- * mksckPageListLock for the next for loop.
- */
- MksckPage_DecRefc(mksckPage);
- spin_lock(&mksckPageListLock);
- break;
- }
- }
-
- /* mksckPageListLock is still locked, mksckPages[ii] can be dereferenced */
- for (ii = 0; ii < MKSCK_MAX_SHARES; ii++) {
- MksckPage *mksckPage = mksckPages[ii];
- if (mksckPage != NULL) {
- uint32 lState = ATOMIC_GETO(mksckPage->mutex.state);
- uint32 isOpened = 0; /* guest has an implicit ref */
-
- seq_printf(m, "MksckPage[%02d]: { vmId = %4x(%c), refC = %2d%s",
- ii, mksckPage->vmId,
- mksckPage->isGuest?'G':'H',
- ATOMIC_GETO(mksckPage->refCount),
- (isPageMapped&(1<<ii) ? "*" : ""));
-
- if (lState) {
- seq_printf(m, ", lock=%x locked by line %d, unlocked by %d",
- lState, mksckPage->mutex.line, mksckPage->mutex.lineUnl);
- }
-
-
- if (!mksckPage->isGuest) {
- struct task_struct *target;
- seq_printf(m, ", tgid = %d", mksckPage->tgid);
-
- rcu_read_lock();
-
- target = pid_task(find_vpid(mksckPage->tgid), PIDTYPE_PID);
- seq_printf(m, "(%s)", target ? target->comm : "no such process");
-
- rcu_read_unlock();
- } else {
- ATOMIC_ADDV(mksckPage->refCount, 1);
- spin_unlock(&mksckPageListLock);
-
- err = Mutex_Lock(&mksckPage->mutex, MutexModeEX);
- vm = (MvpkmVM *) mksckPage->vmHKVA;
-
- if (err == 0 && vm && vm->wsp) {
- isOpened = vm->wsp->isOpened;
- }
- Mutex_Unlock(&mksckPage->mutex, MutexModeEX);
- MksckPage_DecRefc(mksckPage);
- spin_lock(&mksckPageListLock);
- /*
- * As the mksckPageListLock was unlocked, nothing
- * prevented the MksckPage_DecRefc from actually freeing
- * the page. Lets verify that the page is still there.
- */
- if (mksckPage != mksckPages[ii]) {
- seq_printf(m, " released }\n");
- continue;
- }
- }
- seq_printf(m, ", sockets[] = {");
-
- for (jj = 0; jj < mksckPage->numAllocSocks; jj++, isOpened >>= 1) {
- Mksck *mksck = mksckPage->sockets + jj;
-
- if (ATOMIC_GETO(mksck->refCount)) {
- uint32 blocked;
- lState = ATOMIC_GETO(mksck->mutex.state);
- seq_printf(m, "\n { addr = %8x, refC = %2d%s%s%s",
- mksck->addr.addr,
- ATOMIC_GETO(mksck->refCount),
- (isOpened & 1 ? "*" : ""),
- (mksck->shutDown & MKSCK_SHUT_RD ? " SHUTD_RD":""),
- (mksck->shutDown & MKSCK_SHUT_WR ? " SHUTD_WR":""));
-
- if (mksck->peer) {
- seq_printf(m, ", peerAddr = %8x",
- mksck->peerAddr.addr);
- }
-
- if (lState) {
- seq_printf(m, ", lock=%x locked by line %d, unlocked by %d",
- lState, mksck->mutex.line, mksck->mutex.lineUnl);
- }
-
- if ((blocked = ATOMIC_GETO(mksck->mutex.blocked))) {
- seq_printf(m, ", blocked=%d", blocked);
- }
-
- seq_printf(m, " }");
- }
- }
- seq_printf(m, " } }\n");
- }
- }
- spin_unlock(&mksckPageListLock);
-
- return 0;
-}
-
-
-static int
-MksckPageInfoOpen(struct inode *inode, struct file *file)
-{
- return single_open(file, MksckPageInfoShow, inode->i_private);
-}
-
-static const struct file_operations mksckPageInfoFops = {
- .open = MksckPageInfoOpen,
- .read = seq_read,
- .llseek = seq_lseek,
- .release = single_release,
-};
-
-static struct dentry *mksckPageDentry = NULL;
-
-void
-MksckPageInfo_Init(void)
-{
- mksckPageDentry = debugfs_create_file("mksckPage",
- S_IROTH,
- NULL,
- NULL,
- &mksckPageInfoFops);
-}
-
-void
-MksckPageInfo_Exit(void)
-{
- if (mksckPageDentry) {
- debugfs_remove(mksckPageDentry);
- }
-}
generated by cgit v1.1 at 2024-05-05 22:39:41 +0000