monlib.c

完整的Bell实验室的嵌入式文件系统TFS

    int ret;

    monLock();
    ret = _tfslink(src,target);
    monUnlock();
    return(ret);
}

int
mon_tfsunlink(char *name)
{
    int ret;

    monLock();
    ret = _tfsunlink(name);
    monUnlock();
    return(ret);
}

int
mon_tfsrun(char **name,int verbose)
{
    int ret;

    monLock();
    ret = _tfsrun(name,verbose);
    monUnlock();
    return(ret);
}

struct tfshdr *
mon_tfsnext(struct tfshdr *fp)
{
    struct tfshdr *ret;

    monLock();
    ret = _tfsnext(fp);
    monUnlock();
    return(ret);
}

int
mon_tfstruncate(int tfd, long len)
{
    int ret;

    monLock();
    ret = _tfstruncate(tfd,len);
    monUnlock();
    return(ret);
}

int
mon_tfseof(int tfd)
{
    int ret;

    monLock();
    ret = _tfseof(tfd);
    monUnlock();
    return(ret);
}

int
mon_tfsfstat(char *name, struct tfshdr *fp)
{
    int ret;

    monLock();
    ret = _tfsfstat(name,fp);
    monUnlock();
    return(ret);
}

struct tfshdr *
mon_tfsstat(char *name)
{
    struct tfshdr *ret;

    monLock();
    ret = _tfsstat(name);
    monUnlock();
    return(ret);
}

int
mon_tfsread(int fd, char *buf, int cnt)
{
    int ret;

    monLock();
    ret = _tfsread(fd,buf,cnt);
    monUnlock();
    return(ret);
}

int
mon_tfswrite(int fd, char *buf, int cnt)
{
    int ret;

    monLock();
    ret = _tfswrite(fd,buf,cnt);
    monUnlock();
    return(ret);
}

int
mon_tfsopen(char *file,long flagmode,char *buf)
{
    int ret;

    monLock();
    ret = _tfsopen(file,flagmode,buf);
    monUnlock();
    return(ret);
}

int
mon_tfsclose(int fd,char *info)
{
    int ret;

    monLock();
    ret = _tfsclose(fd,info);
    monUnlock();
    return(ret);
}

int
mon_tfsseek(int fd, int offset, int whence)
{
    int ret;

    monLock();
    ret = _tfsseek(fd,offset,whence);
    monUnlock();
    return(ret);
}

int
mon_tfsgetline(int fd,char *bp,int max)
{
    int ret;

    monLock();
    ret = _tfsgetline(fd,bp,max);
    monUnlock();
    return(ret);
}

int
mon_tfsipmod(char *name,char *buf,int offset,int size)
{
    int ret;

    monLock();
    ret = _tfsipmod(name,buf,offset,size);
    monUnlock();
    return(ret);
}

long
mon_tfsctrl(int rqst,long arg1,long arg2)
{
    long    ret;

    monLock();
    ret = _tfsctrl(rqst,arg1,arg2);
    monUnlock();
    return(ret);
}

long
mon_tfstell(int fd)
{
    long    ret;

    monLock();
    ret = _tfstell(fd);
    monUnlock();
    return(ret);
}

int
mon_addcommand(struct monCommand *cmd)
{
    int ret;

    monLock();
    ret = _addcommand(cmd);
    monUnlock();
    return(ret);
}

int
mon_docommand(char *cmdline,int verbose)
{
    int ret;

    monLock();
    ret = _docommand(cmdline,verbose);
    monUnlock();
    return(ret);
}

void
mon_getargv(int *argc,char ***argv)
{
    monLock();
    _getargv(argc,argv);
    monUnlock();
}

unsigned short
mon_xcrc16(char *buf,long nbytes)
{
    unsigned short ret;

    monLock();
    ret = _xcrc16(buf,nbytes);
    monUnlock();
    return(ret);
}

int
mon_pioget(char port,int bitnum)
{
    int ret;

    monLock();
    ret = _pioget(port,bitnum);
    monUnlock();
    return(ret);
}

void
mon_pioset(char port,int bitnum)
{
    monLock();
    _pioset(port,bitnum);
    monUnlock();
}

void
mon_pioclr(char port,int bitnum)
{
    monLock();
    _pioclr(port,bitnum);
    monUnlock();
}

unsigned long
mon_intsoff(void)
{
    unsigned long ret;

    monLock();
    ret = _intsoff();
    monUnlock();
    return(ret);
}

void
mon_intsrestore(unsigned long msr)
{
    monLock();
    _intsrestore(msr);
    monUnlock();
}

void
mon_appexit(int val)
{
    monLock();
    _appexit(val);
    monUnlock();
}

char *
mon_malloc(int size)
{
    char *ret;

    monLock();
    ret = _malloc(size);
    monUnlock();
    return(ret);
}

void
mon_free(char *cp)
{
    monLock();
    _free(cp);
    monUnlock();
}

int
mon_getline(char *buf,int max,int ledit)
{
    int ret;

    monLock();
    ret = _getline(buf,max,ledit);
    monUnlock();
    return(ret);
}

int
mon_decompress(char *src,int srcsize,char *dest)
{
    int ret;

    monLock();
    ret = _decompress(src,srcsize,dest);
    monUnlock();
    return(ret);
}

int
mon_heapxtend(char *base,int size)
{
    int ret;

    monLock();
    ret = _heapextend(base,size);
    monUnlock();
    return(ret);
}

void
mon_bbc(char *filename, int lineno)
{
    _bbc(filename, lineno);
}

void
mon_profiler(void *pdata)
{
    _profiler(pdata);
}

void
mon_memtrace(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
char *fmt;
int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
{
    _memtrace(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
}

char *
mon_version(void)
{
    char *ret;

    monLock();
    ret = _version();
    monUnlock();
    return(ret);
}