syslin.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/* ////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2004-2005 Intel Corporation. All Rights Reserved.
//
//
//
*/

#if defined(SYSLIN)

#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <malloc.h>
#include <stdio.h>

#include "syscross.h"

struct sSysFile
{
    int hande;
};

typedef struct sSysFile SSysFile;

SysCallResult sysFileCreate(
    const char       *fileName,
    SysAccessRight    access,
    SysCreateOptions  createOptions,
    SysAccessType     /* accessOptimization */, /* is ignored on linux */
    SysFile          *file
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;

    int    oflag = 0;
    mode_t mode  = S_IRUSR | S_IWUSR | S_IROTH | S_IRGRP;

    *file = (SSysFile *)malloc(sizeof(SSysFile));

    if(!(*file))
    {
        result = SYS_CALL_RESULT_FAIL_NO_MEMORY;
        goto fail;
    }

    if(access & SYS_ACCESS_RIGHT_READ)
    {
        if(access & SYS_ACCESS_RIGHT_WRITE)
        {
            oflag |= O_RDWR;
        }
        else
        {
            oflag |= O_RDONLY;
        }
    }
    else
    {
        if(access & SYS_ACCESS_RIGHT_WRITE)
        {
            oflag |= O_WRONLY;
        }
    }

    switch(createOptions)
    {
    case SYS_CREATE_OPTIONS_NEW_ONLY:               oflag |= O_CREAT|O_EXCL;    break;
    case SYS_CREATE_OPTIONS_EXISTING_ONLY_KEEP:     oflag |= 0;                 break;
    case SYS_CREATE_OPTIONS_EXISTING_ONLY_TRUNCATE: oflag |= O_TRUNC;           break;
    case SYS_CREATE_OPTIONS_ALWAYS_KEEP:            oflag |= O_CREAT;           break;
    case SYS_CREATE_OPTIONS_ALWAYS_TRUNCATE:        oflag |= O_CREAT|O_TRUNC;   break;
    default:
        result = SYS_CALL_RESULT_FAIL_BAD_OPTION;
        goto fail;
    }

    (*file)->hande = open(fileName, oflag, mode);

    if((*file)->hande == -1)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

    goto ok;

fail:
    if(*file) { free(*file); *file = 0; }
ok:
    return result;
}


SysCallResult sysFileClose (
    SysFile  file
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;

    if(file)
    {
        if(close(file->hande) == -1);
            result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        free(file);
    }

    return result;
}


SysCallResult sysFileGetSize (
    SysFile       file,
    unsigned int *size
)
{
    struct stat st;

    if(fstat(file->hande, &st ) == -1)
    {
        *size = 0;
        return SYS_CALL_RESULT_FAIL_NON_SPECIFIC;

    }
    *size = S_ISDIR(st.st_mode) ? 0 : st.st_size;

    return SYS_CALL_RESULT_OK;
}

struct sSysMemoryMap
{
    int                 fileHande;
    SysMemoryMapAccess  access;
    unsigned int        maxSize;
};

typedef struct sSysMemoryMap SSysMemoryMap;

SysCallResult sysMemoryMapCreate    (
    SysFile             file,
    SysMemoryMapAccess  access,
    unsigned int        maxSize,
    SysMemoryMap       *memoryMap
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;
    off_t oldPos;

    *memoryMap = (SSysMemoryMap *)malloc(sizeof(SSysMemoryMap));

    if(!(*memoryMap))
    {
        result = SYS_CALL_RESULT_FAIL_NO_MEMORY;
        goto fail;
    }

    (*memoryMap)->fileHande = file->hande;
    (*memoryMap)->access    = access;
    (*memoryMap)->maxSize   = maxSize;

    oldPos = lseek((*memoryMap)->fileHande, maxSize - 1, SEEK_SET);
    if(oldPos == -1)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

{
    int flags = fcntl((*memoryMap)->fileHande, F_GETFL);

    if(flags == -1)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }


    if( (flags & (O_RDWR | O_RDONLY | O_WRONLY)) == O_RDONLY)
    {
        char a;
        if(read((*memoryMap)->fileHande, &a, 1) == -1)
        {
            lseek((*memoryMap)->fileHande, oldPos, SEEK_SET);
            result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
            goto fail;
        }
    }
    else
    {
        char a = '\0';
        if(write((*memoryMap)->fileHande, &a, 1) == -1)
        {
            lseek((*memoryMap)->fileHande, oldPos, SEEK_SET);
            result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
            goto fail;
        }
    }
}


    if(lseek((*memoryMap)->fileHande, oldPos, SEEK_SET) == -1)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

    goto ok;

fail:
    if(*memoryMap) { free(*memoryMap); *memoryMap = 0; }
ok:
    return result;
}

SysCallResult sysMemoryMapClose     (
    SysMemoryMap memoryMap
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;

    if(memoryMap)
    {
        free(memoryMap);
    }

    return result;
}


struct sSysMemoryMapView
{
    void   *base;
    void   *addr;
    size_t  size;
};

typedef struct sSysMemoryMapView SSysMemoryMapView;

SysCallResult sysMemoryMapViewCreate (
    SysMemoryMap        memoryMap,
    SysMemoryMapAccess  access,
    unsigned int        offset,
    unsigned int        size,
    SysMemoryMapView   *memoryMapView
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;
    unsigned int alignedOffset;
    unsigned int offsetToAlign;

    int flags;
    int prot;

    if(offset)
    {
        unsigned int pageSize =  sysconf(_SC_PAGE_SIZE);
        offsetToAlign = (offset % pageSize);
        alignedOffset = offset - offsetToAlign;
    }
    else
    {
        alignedOffset = offset;
        offsetToAlign = 0;
    }

    *memoryMapView = (SSysMemoryMapView *)malloc(sizeof(SSysMemoryMapView));

    if(!(*memoryMapView))
    {
        result = SYS_CALL_RESULT_FAIL_NO_MEMORY;
        goto fail;
    }

    if(size > memoryMap->maxSize)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

    if(
        (
            (memoryMap->access == SYS_MEMORY_MAP_ACCESS_READ_WRITE_COPY)
        ||
            (memoryMap->access == SYS_MEMORY_MAP_ACCESS_READ_ONLY)
        )
    && (access != memoryMap->access)
    )
    {
        /* access mismatch */
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

    switch(access)
    {
    case SYS_MEMORY_MAP_ACCESS_READ_WRITE_COPY: flags = MAP_PRIVATE; prot = PROT_READ | PROT_WRITE; break;
    case SYS_MEMORY_MAP_ACCESS_READ_WRITE:      flags = MAP_SHARED;  prot = PROT_READ | PROT_WRITE; break;
    case SYS_MEMORY_MAP_ACCESS_READ_ONLY:       flags = MAP_PRIVATE; prot = PROT_READ;              break;
    default:
        result = SYS_CALL_RESULT_FAIL_BAD_OPTION;
        goto fail;
    }

    if(size)
    {
        (*memoryMapView)->base = mmap(0, size + offsetToAlign, prot, flags, memoryMap->fileHande, alignedOffset);
        (*memoryMapView)->size = size + offsetToAlign;

        if((*memoryMapView)->base == MAP_FAILED)
        {
            result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
            goto fail;
        }
    }
    else
    {
        (*memoryMapView)->base = 0;
        (*memoryMapView)->size = 0;
    }


    (*memoryMapView)->addr = &(((char*)(*memoryMapView)->base)[offsetToAlign]);

    goto ok;

fail:
    if(*memoryMapView) { free(*memoryMapView); *memoryMapView = 0; }
ok:
    return result;
}

SysCallResult sysMemoryMapViewClose (
    SysMemoryMapView memoryMapView
)
{
    int sysres = SYS_CALL_RESULT_OK;

    if(!memoryMapView) return SYS_CALL_RESULT_OK;

    if(memoryMapView->size) sysres = munmap(memoryMapView->base, memoryMapView->size);

    free(memoryMapView);
    if(sysres!=-1)
        return SYS_CALL_RESULT_OK;

    return SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
}

SysCallResult sysMemoryMapViewGetAddr(
    SysMemoryMapView   memoryMapView,
    void             **addr
)
{
    *addr = memoryMapView->addr;

    if(*addr)
        return SYS_CALL_RESULT_OK;

    return SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
}

#endif // SYSLIN