Subversion Repositories funbase_ip_library

/*
 * Copyright (c) 2011, Mentor Graphics Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. Neither the name of the <ORGANIZATION> nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
/* This file allows the shared memory transport to mmap a file rather than
 * requiring dedicated physical memory. This is useful for development and
 * debugging, but obviously can only work for MCAPI processes within a single
 * OS (single filesystem). In addition to mmap(), it uses 0-length SysV message
 * queues as IPIs. */
 
#include <mcapi.h>
#include "shm.h"
#include "shm_os.h"
 
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
 
#include <sys/ipc.h>
#include <sys/msg.h>
 
#define FILENAME "/tmp/mcapi-shm"
 
 
const unsigned int shm_bytes = 0x00100000; /* XXX */
 
static int msgqid;
static pthread_t shm_rx_thread;
 
struct shm_msgbuf {
    long mtype;
};
 
mcapi_status_t openmcapi_shm_notify(mcapi_uint32_t unit_id,
                                    mcapi_uint32_t node_id)
{
    struct shm_msgbuf msg = {node_id + 1};
    int rc;
    mcapi_status_t status = MCAPI_SUCCESS;
 
    rc = msgsnd(msgqid, &msg, 0, 0);
    if (rc == -1)
        status = MGC_MCAPI_ERR_NOT_CONNECTED;
 
    return status;
}
 
mcapi_uint32_t openmcapi_shm_schedunitid(void)
{
    return 0;
}
 
void *openmcapi_shm_map(void)
{
    void *shm;
    int key;
    int fd;
 
    /* Create the file. */
    fd = open(FILENAME, O_RDWR | O_CREAT | O_EXCL, 0660);
    if (fd != -1) {
        /* We created it first. Make it a sparse file of the correct size, then
         * initialize the associated semaphore. */
        lseek(fd, shm_bytes-1, SEEK_SET);
        write(fd, "\0", 1);
    } else {
        if (errno == EEXIST) {
            /* Another process created it, but we can use it. */
            fd = open(FILENAME, O_RDWR, 0660);
        }
    }
    if (fd == -1) {
        perror("open backing file");
        goto out1;
    }
 
    key = ftok(FILENAME, 'A');
    if (key == -1) {
        perror("ftok");
        goto out2;
    }
 
    msgqid = msgget(key, IPC_CREAT | 0660);
    if (msgqid == -1) {
        perror("msgget");
        goto out2;
    }
 
    /* mmap it. */
    shm = mmap(NULL, shm_bytes, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (shm == MAP_FAILED) {
        perror("mmap shared memory");
        goto out2;
    }
 
    /* Don't need the original fd around any more. */
    close(fd);
 
    return shm;
 
out2:
    close(fd);
out1:
    return NULL;
}
 
static void *mcapi_receive_thread(void *data)
{
    int rc;
    static struct shm_msgbuf msg = {0};
 
    do {
        /* Block until data for this node is available. */
        rc = msgrcv(msgqid, &msg, 0, MCAPI_Node_ID + 1, 0);
        if (rc < 0) {
            /* This likely means the other side has already torn down the
             * message queue, so just exit. */
            break;
        }
 
        /* Obtain lock so we can safely manipulate the RX_Queue. */
        MCAPI_Lock_RX_Queue();
 
        /* Process the incoming data. */
        shm_poll();
 
        MCAPI_Unlock_RX_Queue(0);
 
    } while (1);
 
    return NULL;
}
 
/* Now that SM_Mgmt_Blk has been initialized, we can start the RX thread. */
mcapi_status_t openmcapi_shm_os_init(void)
{
    mcapi_status_t mcapi_status = MCAPI_SUCCESS;
    int rc;
 
    rc = pthread_create(&shm_rx_thread, NULL, mcapi_receive_thread, NULL);
    if (rc) {
        perror("couldn't create pthread");
        mcapi_status = MCAPI_ERR_GENERAL;
    }
 
    return mcapi_status;
}
 
/* Finalize the SM driver OS specific layer. */
mcapi_status_t openmcapi_shm_os_finalize(void)
{
    mcapi_status_t mcapi_status = MCAPI_SUCCESS;
    int rc;
 
    rc = pthread_cancel(shm_rx_thread);
    if (rc) {
        perror("couldn't cancel thread");
        mcapi_status = MCAPI_ERR_GENERAL;
    }
 
    return mcapi_status;
}
 
void openmcapi_shm_unmap(void *shm)
{
    /* File and message queue will be removed multiple times, once by each
     * process, but that's OK. */
    unlink(FILENAME);
    msgctl(msgqid, IPC_RMID, NULL);
 
    munmap(shm, shm_bytes);
}