[thirdparty/qemu.git] / linux-user / m68k-semi.c

/*
 *  m68k/ColdFire Semihosting ssycall interface
 * 
 *  Copyright (c) 2005 CodeSourcery, LLC. Written by Paul Brook.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>

#include "qemu.h"

#define HOSTED_EXIT  0
#define HOSTED_PUTCHAR 1 /* Obsolete */
#define HOSTED_OPEN 2
#define HOSTED_CLOSE 3
#define HOSTED_READ 4
#define HOSTED_WRITE 5
#define HOSTED_LSEEK 6
#define HOSTED_RENAME 7
#define HOSTED_UNLINK 8
#define HOSTED_STAT 9
#define HOSTED_FSTAT 10
#define HOSTED_GETTIMEOFDAY 11
#define HOSTED_ISATTY 12
#define HOSTED_SYSTEM 13

typedef uint32_t gdb_mode_t;
typedef uint32_t gdb_time_t;

struct m68k_gdb_stat {
  uint32_t    gdb_st_dev;     /* device */
  uint32_t    gdb_st_ino;     /* inode */
  gdb_mode_t  gdb_st_mode;    /* protection */
  uint32_t    gdb_st_nlink;   /* number of hard links */
  uint32_t    gdb_st_uid;     /* user ID of owner */
  uint32_t    gdb_st_gid;     /* group ID of owner */
  uint32_t    gdb_st_rdev;    /* device type (if inode device) */
  uint64_t    gdb_st_size;    /* total size, in bytes */
  uint64_t    gdb_st_blksize; /* blocksize for filesystem I/O */
  uint64_t    gdb_st_blocks;  /* number of blocks allocated */
  gdb_time_t  gdb_st_atime;   /* time of last access */
  gdb_time_t  gdb_st_mtime;   /* time of last modification */
  gdb_time_t  gdb_st_ctime;   /* time of last change */
};

struct gdb_timeval {
  gdb_time_t tv_sec;  /* second */
  uint64_t tv_usec;   /* microsecond */
};

#define GDB_O_RDONLY   0x0
#define GDB_O_WRONLY   0x1
#define GDB_O_RDWR     0x2
#define GDB_O_APPEND   0x8
#define GDB_O_CREAT  0x200
#define GDB_O_TRUNC  0x400
#define GDB_O_EXCL   0x800

static int translate_openflags(int flags)
{
    int hf;

    if (flags & GDB_O_WRONLY)
        hf = O_WRONLY;
    else if (flags & GDB_O_RDWR)
        hf = O_RDWR;
    else
        hf = O_RDONLY;

    if (flags & GDB_O_APPEND) hf |= O_APPEND;
    if (flags & GDB_O_CREAT) hf |= O_CREAT;
    if (flags & GDB_O_TRUNC) hf |= O_TRUNC;
    if (flags & GDB_O_EXCL) hf |= O_EXCL;

    return hf;
}

static void translate_stat(struct m68k_gdb_stat *p, struct stat *s)
{
    p->gdb_st_dev = tswap16(s->st_dev);
    p->gdb_st_ino = tswap16(s->st_ino);
    p->gdb_st_mode = tswap32(s->st_mode);
    p->gdb_st_nlink = tswap16(s->st_nlink);
    p->gdb_st_uid = tswap16(s->st_uid);
    p->gdb_st_gid = tswap16(s->st_gid);
    p->gdb_st_rdev = tswap16(s->st_rdev);
    p->gdb_st_size = tswap32(s->st_size);
    p->gdb_st_atime = tswap32(s->st_atime);
    p->gdb_st_mtime = tswap32(s->st_mtime);
    p->gdb_st_ctime = tswap32(s->st_ctime);
    p->gdb_st_blksize = tswap32(s->st_blksize);
    p->gdb_st_blocks = tswap32(s->st_blocks);
}

static inline uint32_t check_err(CPUM68KState *env, uint32_t code)
{
  if (code == (uint32_t)-1) {
      env->sr |= CCF_C;
  } else {
      env->sr &= ~CCF_C;
      env->dregs[0] = code;
  }
  return code;
}

#define ARG(x) tswap32(args[x])
void do_m68k_semihosting(CPUM68KState *env, int nr)
{
    uint32_t *args;

    args = (uint32_t *)env->dregs[1];
    switch (nr) {
    case HOSTED_EXIT:
        exit(env->dregs[0]);
    case HOSTED_OPEN:
        /* Assume name is NULL terminated.  */
        check_err(env, open((char *)ARG(0), translate_openflags(ARG(2)),
                            ARG(3)));
        break;
    case HOSTED_CLOSE:
        {
            /* Ignore attempts to close stdin/out/err.  */
            int fd = ARG(0);
            if (fd > 2)
              check_err(env, close(fd));
            else
              check_err(env, 0);
            break;
        }
    case HOSTED_READ:
        check_err(env, read(ARG(0), (void *)ARG(1), ARG(2)));
        break;
    case HOSTED_WRITE:
        check_err(env, write(ARG(0), (void *)ARG(1), ARG(2)));
        break;
    case HOSTED_LSEEK:
        {
            uint64_t off;
            off = (uint32_t)ARG(2) | ((uint64_t)ARG(1) << 32);
            check_err(env, lseek(ARG(0), off, ARG(3)));
        }
        break;
    case HOSTED_RENAME:
        /* Assume names are NULL terminated.  */
        check_err(env, rename((char *)ARG(0), (char *)ARG(2)));
        break;
    case HOSTED_UNLINK:
        /* Assume name is NULL terminated.  */
        check_err(env, unlink((char *)ARG(0)));
        break;
    case HOSTED_STAT:
        /* Assume name is NULL terminated.  */
        {
            struct stat s;
            int rc;
            rc = check_err(env, stat((char *)ARG(0), &s));
            if (rc == 0) {
                translate_stat((struct m68k_gdb_stat *)ARG(2), &s);
            }
        }
        break;
    case HOSTED_FSTAT:
        {
            struct stat s;
            int rc;
            rc = check_err(env, fstat(ARG(0), &s));
            if (rc == 0) {
                translate_stat((struct m68k_gdb_stat *)ARG(1), &s);
            }
        }
        break;
    case HOSTED_GETTIMEOFDAY:
        {
            struct timeval tv;
            struct gdb_timeval *p;
            int rc;
            rc = check_err(env, gettimeofday(&tv, NULL));
            if (rc != 0) {
                p = (struct gdb_timeval *)ARG(0);
                p->tv_sec = tswap32(tv.tv_sec);
                p->tv_usec = tswap64(tv.tv_usec);
            }
        }
        break;
    case HOSTED_ISATTY:
        check_err(env, isatty(ARG(0)));
        break;
    case HOSTED_SYSTEM:
        /* Assume name is NULL terminated.  */
        check_err(env, system((char *)ARG(0)));
        break;
    default:
        cpu_abort(env, "Unsupported semihosting syscall %d\n", nr);
    }
}
Commit	Line	Data
e6e5906b PB	1	/*
	2	* m68k/ColdFire Semihosting ssycall interface
	3	*
	4	* Copyright (c) 2005 CodeSourcery, LLC. Written by Paul Brook.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*/
	20
	21	#include <sys/types.h>
	22	#include <sys/stat.h>
	23	#include <errno.h>
	24	#include <fcntl.h>
	25	#include <unistd.h>
	26	#include <stdlib.h>
	27	#include <stdio.h>
	28	#include <sys/time.h>
	29	#include <time.h>
	30
	31	#include "qemu.h"
	32
	33	#define HOSTED_EXIT 0
	34	#define HOSTED_PUTCHAR 1 /* Obsolete */
	35	#define HOSTED_OPEN 2
	36	#define HOSTED_CLOSE 3
	37	#define HOSTED_READ 4
	38	#define HOSTED_WRITE 5
	39	#define HOSTED_LSEEK 6
	40	#define HOSTED_RENAME 7
	41	#define HOSTED_UNLINK 8
	42	#define HOSTED_STAT 9
	43	#define HOSTED_FSTAT 10
	44	#define HOSTED_GETTIMEOFDAY 11
	45	#define HOSTED_ISATTY 12
	46	#define HOSTED_SYSTEM 13
	47
	48	typedef uint32_t gdb_mode_t;
	49	typedef uint32_t gdb_time_t;
	50
	51	struct m68k_gdb_stat {
	52	uint32_t gdb_st_dev; /* device */
	53	uint32_t gdb_st_ino; /* inode */
	54	gdb_mode_t gdb_st_mode; /* protection */
	55	uint32_t gdb_st_nlink; /* number of hard links */
	56	uint32_t gdb_st_uid; /* user ID of owner */
	57	uint32_t gdb_st_gid; /* group ID of owner */
	58	uint32_t gdb_st_rdev; /* device type (if inode device) */
	59	uint64_t gdb_st_size; /* total size, in bytes */
	60	uint64_t gdb_st_blksize; /* blocksize for filesystem I/O */
	61	uint64_t gdb_st_blocks; /* number of blocks allocated */
	62	gdb_time_t gdb_st_atime; /* time of last access */
	63	gdb_time_t gdb_st_mtime; /* time of last modification */
	64	gdb_time_t gdb_st_ctime; /* time of last change */
65	};
66
67	struct gdb_timeval {
68	gdb_time_t tv_sec; /* second */
69	uint64_t tv_usec; /* microsecond */
70	};
71
72	#define GDB_O_RDONLY 0x0
73	#define GDB_O_WRONLY 0x1
74	#define GDB_O_RDWR 0x2
75	#define GDB_O_APPEND 0x8
76	#define GDB_O_CREAT 0x200
77	#define GDB_O_TRUNC 0x400
78	#define GDB_O_EXCL 0x800
79
80	static int translate_openflags(int flags)
81	{
82	int hf;
83
84	if (flags & GDB_O_WRONLY)
85	hf = O_WRONLY;
86	else if (flags & GDB_O_RDWR)
87	hf = O_RDWR;
88	else
89	hf = O_RDONLY;
90
91	if (flags & GDB_O_APPEND) hf \|= O_APPEND;
92	if (flags & GDB_O_CREAT) hf \|= O_CREAT;
93	if (flags & GDB_O_TRUNC) hf \|= O_TRUNC;
94	if (flags & GDB_O_EXCL) hf \|= O_EXCL;
95
96	return hf;
97	}
98
99	static void translate_stat(struct m68k_gdb_stat p, struct stat s)
100	{
101	p->gdb_st_dev = tswap16(s->st_dev);
102	p->gdb_st_ino = tswap16(s->st_ino);
103	p->gdb_st_mode = tswap32(s->st_mode);
104	p->gdb_st_nlink = tswap16(s->st_nlink);
105	p->gdb_st_uid = tswap16(s->st_uid);
106	p->gdb_st_gid = tswap16(s->st_gid);
107	p->gdb_st_rdev = tswap16(s->st_rdev);
108	p->gdb_st_size = tswap32(s->st_size);
109	p->gdb_st_atime = tswap32(s->st_atime);
110	p->gdb_st_mtime = tswap32(s->st_mtime);
111	p->gdb_st_ctime = tswap32(s->st_ctime);
112	p->gdb_st_blksize = tswap32(s->st_blksize);
113	p->gdb_st_blocks = tswap32(s->st_blocks);
114	}
115
116	static inline uint32_t check_err(CPUM68KState *env, uint32_t code)
117	{
118	if (code == (uint32_t)-1) {
119	env->sr \|= CCF_C;
120	} else {
121	env->sr &= ~CCF_C;
122	env->dregs[0] = code;
123	}
124	return code;
125	}
126
127	#define ARG(x) tswap32(args[x])
128	void do_m68k_semihosting(CPUM68KState *env, int nr)
129	{
130	uint32_t *args;
131
132	args = (uint32_t *)env->dregs[1];
133	switch (nr) {
134	case HOSTED_EXIT:
135	exit(env->dregs[0]);
136	case HOSTED_OPEN:
137	/* Assume name is NULL terminated. */
138	check_err(env, open((char *)ARG(0), translate_openflags(ARG(2)),
139	ARG(3)));
140	break;
141	case HOSTED_CLOSE:
142	{
143	/* Ignore attempts to close stdin/out/err. */
144	int fd = ARG(0);
145	if (fd > 2)
146	check_err(env, close(fd));
147	else
148	check_err(env, 0);
149	break;
150	}
151	case HOSTED_READ:
152	check_err(env, read(ARG(0), (void *)ARG(1), ARG(2)));
153	break;
154	case HOSTED_WRITE:
155	check_err(env, write(ARG(0), (void *)ARG(1), ARG(2)));
156	break;
157	case HOSTED_LSEEK:
158	{
159	uint64_t off;
160	off = (uint32_t)ARG(2) \| ((uint64_t)ARG(1) << 32);
161	check_err(env, lseek(ARG(0), off, ARG(3)));
162	}
163	break;
164	case HOSTED_RENAME:
165	/* Assume names are NULL terminated. */
166	check_err(env, rename((char )ARG(0), (char )ARG(2)));
167	break;
168	case HOSTED_UNLINK:
169	/* Assume name is NULL terminated. */
170	check_err(env, unlink((char *)ARG(0)));
171	break;
172	case HOSTED_STAT:
173	/* Assume name is NULL terminated. */
174	{
175	struct stat s;
176	int rc;
177	rc = check_err(env, stat((char *)ARG(0), &s));
178	if (rc == 0) {
179	translate_stat((struct m68k_gdb_stat *)ARG(2), &s);
180	}
181	}
182	break;
183	case HOSTED_FSTAT:
184	{
185	struct stat s;
186	int rc;
187	rc = check_err(env, fstat(ARG(0), &s));
188	if (rc == 0) {
189	translate_stat((struct m68k_gdb_stat *)ARG(1), &s);
190	}
191	}
192	break;
193	case HOSTED_GETTIMEOFDAY:
194	{
195	struct timeval tv;
196	struct gdb_timeval *p;
197	int rc;
198	rc = check_err(env, gettimeofday(&tv, NULL));
199	if (rc != 0) {
200	p = (struct gdb_timeval *)ARG(0);
201	p->tv_sec = tswap32(tv.tv_sec);
202	p->tv_usec = tswap64(tv.tv_usec);
203	}
204	}
205	break;
206	case HOSTED_ISATTY:
207	check_err(env, isatty(ARG(0)));
208	break;
209	case HOSTED_SYSTEM:
210	/* Assume name is NULL terminated. */
211	check_err(env, system((char *)ARG(0)));
212	break;
213	default:
214	cpu_abort(env, "Unsupported semihosting syscall %d\n", nr);
215	}
216	}