« back to all changes in this revision
Viewing changes to linux-user/syscall.c
- browse files at revision 1.1.7
- compare with another revision
- download diff
- download tarball
- view history from revision 1.1.7
- Committer: Bazaar Package Importer
- Author(s): Soren Hansen
- Date: 2007-10-22 17:07:29 UTC
- mto: (1.5.1) (10.1.1 squeeze) (11.1.1 experimental) (12.1.1 sid) (6.1.1 sid)
- mto: This revision was merged to the branch mainline in revision 3.
- Revision ID: james.westby@ubuntu.com-20071022170729-4ihaxntpl01xg29n
Tags: upstream-0.9.0+20070816
Import upstream version 0.9.0+20070816
- files added:
- block-parallels.c
- linux-user/alpha
- linux-user/ppc64
- linux-user/x86_64
- target-alpha
- files removed:
- linux-user/m68k-semi.c
- files modified:
- Changelog
added
removed
linux-user/syscall.c
28
28
#include <fcntl.h>
29
29
#include <time.h>
30
30
#include <sys/types.h>
31
#include <sys/ipc.h>
32
#include <sys/msg.h>
31
33
#include <sys/wait.h>
32
34
#include <sys/time.h>
33
35
#include <sys/stat.h>
34
36
#include <sys/mount.h>
37
#include <sys/prctl.h>
35
38
#include <sys/resource.h>
36
39
#include <sys/mman.h>
37
40
#include <sys/swap.h>
71
74
//#define DEBUG
72
75
73
76
#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
74
|| defined(TARGET_M68K)
77
|| defined(TARGET_M68K) || defined(TARGET_SH4)
75
78
/* 16 bit uid wrappers emulation */
76
79
#define USE_UID16
77
80
#endif
140
143
#define __NR_sys_getdents __NR_getdents
141
144
#define __NR_sys_getdents64 __NR_getdents64
142
145
#define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
146
#define __NR_sys_syslog __NR_syslog
147
#define __NR_sys_tgkill __NR_tgkill
148
#define __NR_sys_tkill __NR_tkill
143
149
144
150
#if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
145
151
#define __NR__llseek __NR_lseek
159
165
_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
160
166
loff_t *, res, uint, wh);
161
167
_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
168
_syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
169
#ifdef TARGET_NR_tgkill
170
_syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
171
#endif
172
#ifdef TARGET_NR_tkill
173
_syscall2(int,sys_tkill,int,tid,int,sig)
174
#endif
162
175
#ifdef __NR_exit_group
163
176
_syscall1(int,exit_group,int,error_code)
164
177
#endif
178
#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
179
_syscall1(int,set_tid_address,int *,tidptr)
180
#endif
165
181
166
182
extern int personality(int);
167
183
extern int flock(int, int);
173
189
extern int getresgid(gid_t *, gid_t *, gid_t *);
174
190
extern int setgroups(int, gid_t *);
175
191
192
/*
193
* This list is the union of errno values overridden in asm-<arch>/errno.h
194
* minus the errnos that are not actually generic to all archs.
195
*/
196
static uint16_t host_to_target_errno_table[1200] = {
197
[EIDRM] = TARGET_EIDRM,
198
[ECHRNG] = TARGET_ECHRNG,
199
[EL2NSYNC] = TARGET_EL2NSYNC,
200
[EL3HLT] = TARGET_EL3HLT,
201
[EL3RST] = TARGET_EL3RST,
202
[ELNRNG] = TARGET_ELNRNG,
203
[EUNATCH] = TARGET_EUNATCH,
204
[ENOCSI] = TARGET_ENOCSI,
205
[EL2HLT] = TARGET_EL2HLT,
206
[EDEADLK] = TARGET_EDEADLK,
207
[ENOLCK] = TARGET_ENOLCK,
208
[EBADE] = TARGET_EBADE,
209
[EBADR] = TARGET_EBADR,
210
[EXFULL] = TARGET_EXFULL,
211
[ENOANO] = TARGET_ENOANO,
212
[EBADRQC] = TARGET_EBADRQC,
213
[EBADSLT] = TARGET_EBADSLT,
214
[EBFONT] = TARGET_EBFONT,
215
[ENOSTR] = TARGET_ENOSTR,
216
[ENODATA] = TARGET_ENODATA,
217
[ETIME] = TARGET_ETIME,
218
[ENOSR] = TARGET_ENOSR,
219
[ENONET] = TARGET_ENONET,
220
[ENOPKG] = TARGET_ENOPKG,
221
[EREMOTE] = TARGET_EREMOTE,
222
[ENOLINK] = TARGET_ENOLINK,
223
[EADV] = TARGET_EADV,
224
[ESRMNT] = TARGET_ESRMNT,
225
[ECOMM] = TARGET_ECOMM,
226
[EPROTO] = TARGET_EPROTO,
227
[EDOTDOT] = TARGET_EDOTDOT,
228
[EMULTIHOP] = TARGET_EMULTIHOP,
229
[EBADMSG] = TARGET_EBADMSG,
230
[ENAMETOOLONG] = TARGET_ENAMETOOLONG,
231
[EOVERFLOW] = TARGET_EOVERFLOW,
232
[ENOTUNIQ] = TARGET_ENOTUNIQ,
233
[EBADFD] = TARGET_EBADFD,
234
[EREMCHG] = TARGET_EREMCHG,
235
[ELIBACC] = TARGET_ELIBACC,
236
[ELIBBAD] = TARGET_ELIBBAD,
237
[ELIBSCN] = TARGET_ELIBSCN,
238
[ELIBMAX] = TARGET_ELIBMAX,
239
[ELIBEXEC] = TARGET_ELIBEXEC,
240
[EILSEQ] = TARGET_EILSEQ,
241
[ENOSYS] = TARGET_ENOSYS,
242
[ELOOP] = TARGET_ELOOP,
243
[ERESTART] = TARGET_ERESTART,
244
[ESTRPIPE] = TARGET_ESTRPIPE,
245
[ENOTEMPTY] = TARGET_ENOTEMPTY,
246
[EUSERS] = TARGET_EUSERS,
247
[ENOTSOCK] = TARGET_ENOTSOCK,
248
[EDESTADDRREQ] = TARGET_EDESTADDRREQ,
249
[EMSGSIZE] = TARGET_EMSGSIZE,
250
[EPROTOTYPE] = TARGET_EPROTOTYPE,
251
[ENOPROTOOPT] = TARGET_ENOPROTOOPT,
252
[EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT,
253
[ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT,
254
[EOPNOTSUPP] = TARGET_EOPNOTSUPP,
255
[EPFNOSUPPORT] = TARGET_EPFNOSUPPORT,
256
[EAFNOSUPPORT] = TARGET_EAFNOSUPPORT,
257
[EADDRINUSE] = TARGET_EADDRINUSE,
258
[EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL,
259
[ENETDOWN] = TARGET_ENETDOWN,
260
[ENETUNREACH] = TARGET_ENETUNREACH,
261
[ENETRESET] = TARGET_ENETRESET,
262
[ECONNABORTED] = TARGET_ECONNABORTED,
263
[ECONNRESET] = TARGET_ECONNRESET,
264
[ENOBUFS] = TARGET_ENOBUFS,
265
[EISCONN] = TARGET_EISCONN,
266
[ENOTCONN] = TARGET_ENOTCONN,
267
[EUCLEAN] = TARGET_EUCLEAN,
268
[ENOTNAM] = TARGET_ENOTNAM,
269
[ENAVAIL] = TARGET_ENAVAIL,
270
[EISNAM] = TARGET_EISNAM,
271
[EREMOTEIO] = TARGET_EREMOTEIO,
272
[ESHUTDOWN] = TARGET_ESHUTDOWN,
273
[ETOOMANYREFS] = TARGET_ETOOMANYREFS,
274
[ETIMEDOUT] = TARGET_ETIMEDOUT,
275
[ECONNREFUSED] = TARGET_ECONNREFUSED,
276
[EHOSTDOWN] = TARGET_EHOSTDOWN,
277
[EHOSTUNREACH] = TARGET_EHOSTUNREACH,
278
[EALREADY] = TARGET_EALREADY,
279
[EINPROGRESS] = TARGET_EINPROGRESS,
280
[ESTALE] = TARGET_ESTALE,
281
[ECANCELED] = TARGET_ECANCELED,
282
[ENOMEDIUM] = TARGET_ENOMEDIUM,
283
[EMEDIUMTYPE] = TARGET_EMEDIUMTYPE,
284
#ifdef ENOKEY
285
[ENOKEY] = TARGET_ENOKEY,
286
#endif
287
#ifdef EKEYEXPIRED
288
[EKEYEXPIRED] = TARGET_EKEYEXPIRED,
289
#endif
290
#ifdef EKEYREVOKED
291
[EKEYREVOKED] = TARGET_EKEYREVOKED,
292
#endif
293
#ifdef EKEYREJECTED
294
[EKEYREJECTED] = TARGET_EKEYREJECTED,
295
#endif
296
#ifdef EOWNERDEAD
297
[EOWNERDEAD] = TARGET_EOWNERDEAD,
298
#endif
299
#ifdef ENOTRECOVERABLE
300
[ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
301
#endif
302
};
303
304
static inline int host_to_target_errno(int err)
305
{
306
if(host_to_target_errno_table[err])
307
return host_to_target_errno_table[err];
308
return err;
309
}
310
176
311
static inline long get_errno(long ret)
177
312
{
178
313
if (ret == -1)
179
return -errno;
314
return -host_to_target_errno(errno);
180
315
else
181
316
return ret;
182
317
}
191
326
192
327
void target_set_brk(target_ulong new_brk)
193
328
{
194
target_original_brk = target_brk = new_brk;
329
target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
195
330
}
196
331
197
332
long do_brk(target_ulong new_brk)
857
992
target_ulong target_addrlen)
858
993
{
859
994
socklen_t addrlen = tget32(target_addrlen);
860
void *addr = alloca(target_addrlen);
995
void *addr = alloca(addrlen);
861
996
long ret;
862
997
863
998
ret = get_errno(getpeername(fd, addr, &addrlen));
872
1007
target_ulong target_addrlen)
873
1008
{
874
1009
socklen_t addrlen = tget32(target_addrlen);
875
void *addr = alloca(target_addrlen);
1010
void *addr = alloca(addrlen);
876
1011
long ret;
877
1012
878
1013
ret = get_errno(getsockname(fd, addr, &addrlen));
1115
1250
uint32_t size;
1116
1251
} shm_regions[N_SHM_REGIONS];
1117
1252
1253
struct target_ipc_perm
1254
{
1255
target_long __key;
1256
target_ulong uid;
1257
target_ulong gid;
1258
target_ulong cuid;
1259
target_ulong cgid;
1260
unsigned short int mode;
1261
unsigned short int __pad1;
1262
unsigned short int __seq;
1263
unsigned short int __pad2;
1264
target_ulong __unused1;
1265
target_ulong __unused2;
1266
};
1267
1268
struct target_semid_ds
1269
{
1270
struct target_ipc_perm sem_perm;
1271
target_ulong sem_otime;
1272
target_ulong __unused1;
1273
target_ulong sem_ctime;
1274
target_ulong __unused2;
1275
target_ulong sem_nsems;
1276
target_ulong __unused3;
1277
target_ulong __unused4;
1278
};
1279
1280
static inline void target_to_host_ipc_perm(struct ipc_perm *host_ip,
1281
target_ulong target_addr)
1282
{
1283
struct target_ipc_perm *target_ip;
1284
struct target_semid_ds *target_sd;
1285
1286
lock_user_struct(target_sd, target_addr, 1);
1287
target_ip=&(target_sd->sem_perm);
1288
host_ip->__key = tswapl(target_ip->__key);
1289
host_ip->uid = tswapl(target_ip->uid);
1290
host_ip->gid = tswapl(target_ip->gid);
1291
host_ip->cuid = tswapl(target_ip->cuid);
1292
host_ip->cgid = tswapl(target_ip->cgid);
1293
host_ip->mode = tswapl(target_ip->mode);
1294
unlock_user_struct(target_sd, target_addr, 0);
1295
}
1296
1297
static inline void host_to_target_ipc_perm(target_ulong target_addr,
1298
struct ipc_perm *host_ip)
1299
{
1300
struct target_ipc_perm *target_ip;
1301
struct target_semid_ds *target_sd;
1302
1303
lock_user_struct(target_sd, target_addr, 0);
1304
target_ip = &(target_sd->sem_perm);
1305
target_ip->__key = tswapl(host_ip->__key);
1306
target_ip->uid = tswapl(host_ip->uid);
1307
target_ip->gid = tswapl(host_ip->gid);
1308
target_ip->cuid = tswapl(host_ip->cuid);
1309
target_ip->cgid = tswapl(host_ip->cgid);
1310
target_ip->mode = tswapl(host_ip->mode);
1311
unlock_user_struct(target_sd, target_addr, 1);
1312
}
1313
1314
static inline void target_to_host_semid_ds(struct semid_ds *host_sd,
1315
target_ulong target_addr)
1316
{
1317
struct target_semid_ds *target_sd;
1318
1319
lock_user_struct(target_sd, target_addr, 1);
1320
target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr);
1321
host_sd->sem_nsems = tswapl(target_sd->sem_nsems);
1322
host_sd->sem_otime = tswapl(target_sd->sem_otime);
1323
host_sd->sem_ctime = tswapl(target_sd->sem_ctime);
1324
unlock_user_struct(target_sd, target_addr, 0);
1325
}
1326
1327
static inline void host_to_target_semid_ds(target_ulong target_addr,
1328
struct semid_ds *host_sd)
1329
{
1330
struct target_semid_ds *target_sd;
1331
1332
lock_user_struct(target_sd, target_addr, 0);
1333
host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm));
1334
target_sd->sem_nsems = tswapl(host_sd->sem_nsems);
1335
target_sd->sem_otime = tswapl(host_sd->sem_otime);
1336
target_sd->sem_ctime = tswapl(host_sd->sem_ctime);
1337
unlock_user_struct(target_sd, target_addr, 1);
1338
}
1339
1118
1340
union semun {
1119
1341
int val;
1120
struct senid_ds *buf;
1342
struct semid_ds *buf;
1121
1343
unsigned short *array;
1122
1344
};
1123
1345
1346
union target_semun {
1347
int val;
1348
target_long buf;
1349
unsigned short int *array;
1350
};
1351
1352
static inline void target_to_host_semun(unsigned long cmd,
1353
union semun *host_su,
1354
target_ulong target_addr,
1355
struct semid_ds *ds)
1356
{
1357
union target_semun *target_su;
1358
1359
switch( cmd ) {
1360
case IPC_STAT:
1361
case IPC_SET:
1362
lock_user_struct(target_su, target_addr, 1);
1363
target_to_host_semid_ds(ds,target_su->buf);
1364
host_su->buf = ds;
1365
unlock_user_struct(target_su, target_addr, 0);
1366
break;
1367
case GETVAL:
1368
case SETVAL:
1369
lock_user_struct(target_su, target_addr, 1);
1370
host_su->val = tswapl(target_su->val);
1371
unlock_user_struct(target_su, target_addr, 0);
1372
break;
1373
case GETALL:
1374
case SETALL:
1375
lock_user_struct(target_su, target_addr, 1);
1376
*host_su->array = tswap16(*target_su->array);
1377
unlock_user_struct(target_su, target_addr, 0);
1378
break;
1379
default:
1380
gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1381
}
1382
}
1383
1384
static inline void host_to_target_semun(unsigned long cmd,
1385
target_ulong target_addr,
1386
union semun *host_su,
1387
struct semid_ds *ds)
1388
{
1389
union target_semun *target_su;
1390
1391
switch( cmd ) {
1392
case IPC_STAT:
1393
case IPC_SET:
1394
lock_user_struct(target_su, target_addr, 0);
1395
host_to_target_semid_ds(target_su->buf,ds);
1396
unlock_user_struct(target_su, target_addr, 1);
1397
break;
1398
case GETVAL:
1399
case SETVAL:
1400
lock_user_struct(target_su, target_addr, 0);
1401
target_su->val = tswapl(host_su->val);
1402
unlock_user_struct(target_su, target_addr, 1);
1403
break;
1404
case GETALL:
1405
case SETALL:
1406
lock_user_struct(target_su, target_addr, 0);
1407
*target_su->array = tswap16(*host_su->array);
1408
unlock_user_struct(target_su, target_addr, 1);
1409
break;
1410
default:
1411
gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1412
}
1413
}
1414
1415
static inline long do_semctl(long first, long second, long third, long ptr)
1416
{
1417
union semun arg;
1418
struct semid_ds dsarg;
1419
int cmd = third&0xff;
1420
long ret = 0;
1421
1422
switch( cmd ) {
1423
case GETVAL:
1424
target_to_host_semun(cmd,&arg,ptr,&dsarg);
1425
ret = get_errno(semctl(first, second, cmd, arg));
1426
host_to_target_semun(cmd,ptr,&arg,&dsarg);
1427
break;
1428
case SETVAL:
1429
target_to_host_semun(cmd,&arg,ptr,&dsarg);
1430
ret = get_errno(semctl(first, second, cmd, arg));
1431
host_to_target_semun(cmd,ptr,&arg,&dsarg);
1432
break;
1433
case GETALL:
1434
target_to_host_semun(cmd,&arg,ptr,&dsarg);
1435
ret = get_errno(semctl(first, second, cmd, arg));
1436
host_to_target_semun(cmd,ptr,&arg,&dsarg);
1437
break;
1438
case SETALL:
1439
target_to_host_semun(cmd,&arg,ptr,&dsarg);
1440
ret = get_errno(semctl(first, second, cmd, arg));
1441
host_to_target_semun(cmd,ptr,&arg,&dsarg);
1442
break;
1443
case IPC_STAT:
1444
target_to_host_semun(cmd,&arg,ptr,&dsarg);
1445
ret = get_errno(semctl(first, second, cmd, arg));
1446
host_to_target_semun(cmd,ptr,&arg,&dsarg);
1447
break;
1448
case IPC_SET:
1449
target_to_host_semun(cmd,&arg,ptr,&dsarg);
1450
ret = get_errno(semctl(first, second, cmd, arg));
1451
host_to_target_semun(cmd,ptr,&arg,&dsarg);
1452
break;
1453
default:
1454
ret = get_errno(semctl(first, second, cmd, arg));
1455
}
1456
1457
return ret;
1458
}
1459
1460
struct target_msqid_ds
1461
{
1462
struct target_ipc_perm msg_perm;
1463
target_ulong msg_stime;
1464
target_ulong __unused1;
1465
target_ulong msg_rtime;
1466
target_ulong __unused2;
1467
target_ulong msg_ctime;
1468
target_ulong __unused3;
1469
target_ulong __msg_cbytes;
1470
target_ulong msg_qnum;
1471
target_ulong msg_qbytes;
1472
target_ulong msg_lspid;
1473
target_ulong msg_lrpid;
1474
target_ulong __unused4;
1475
target_ulong __unused5;
1476
};
1477
1478
static inline void target_to_host_msqid_ds(struct msqid_ds *host_md,
1479
target_ulong target_addr)
1480
{
1481
struct target_msqid_ds *target_md;
1482
1483
lock_user_struct(target_md, target_addr, 1);
1484
target_to_host_ipc_perm(&(host_md->msg_perm),target_addr);
1485
host_md->msg_stime = tswapl(target_md->msg_stime);
1486
host_md->msg_rtime = tswapl(target_md->msg_rtime);
1487
host_md->msg_ctime = tswapl(target_md->msg_ctime);
1488
host_md->__msg_cbytes = tswapl(target_md->__msg_cbytes);
1489
host_md->msg_qnum = tswapl(target_md->msg_qnum);
1490
host_md->msg_qbytes = tswapl(target_md->msg_qbytes);
1491
host_md->msg_lspid = tswapl(target_md->msg_lspid);
1492
host_md->msg_lrpid = tswapl(target_md->msg_lrpid);
1493
unlock_user_struct(target_md, target_addr, 0);
1494
}
1495
1496
static inline void host_to_target_msqid_ds(target_ulong target_addr,
1497
struct msqid_ds *host_md)
1498
{
1499
struct target_msqid_ds *target_md;
1500
1501
lock_user_struct(target_md, target_addr, 0);
1502
host_to_target_ipc_perm(target_addr,&(host_md->msg_perm));
1503
target_md->msg_stime = tswapl(host_md->msg_stime);
1504
target_md->msg_rtime = tswapl(host_md->msg_rtime);
1505
target_md->msg_ctime = tswapl(host_md->msg_ctime);
1506
target_md->__msg_cbytes = tswapl(host_md->__msg_cbytes);
1507
target_md->msg_qnum = tswapl(host_md->msg_qnum);
1508
target_md->msg_qbytes = tswapl(host_md->msg_qbytes);
1509
target_md->msg_lspid = tswapl(host_md->msg_lspid);
1510
target_md->msg_lrpid = tswapl(host_md->msg_lrpid);
1511
unlock_user_struct(target_md, target_addr, 1);
1512
}
1513
1514
static inline long do_msgctl(long first, long second, long ptr)
1515
{
1516
struct msqid_ds dsarg;
1517
int cmd = second&0xff;
1518
long ret = 0;
1519
switch( cmd ) {
1520
case IPC_STAT:
1521
case IPC_SET:
1522
target_to_host_msqid_ds(&dsarg,ptr);
1523
ret = get_errno(msgctl(first, cmd, &dsarg));
1524
host_to_target_msqid_ds(ptr,&dsarg);
1525
default:
1526
ret = get_errno(msgctl(first, cmd, &dsarg));
1527
}
1528
return ret;
1529
}
1530
1531
struct target_msgbuf {
1532
target_ulong mtype;
1533
char mtext[1];
1534
};
1535
1536
static inline long do_msgsnd(long msqid, long msgp, long msgsz, long msgflg)
1537
{
1538
struct target_msgbuf *target_mb;
1539
struct msgbuf *host_mb;
1540
long ret = 0;
1541
1542
lock_user_struct(target_mb,msgp,0);
1543
host_mb = malloc(msgsz+sizeof(long));
1544
host_mb->mtype = tswapl(target_mb->mtype);
1545
memcpy(host_mb->mtext,target_mb->mtext,msgsz);
1546
ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg));
1547
free(host_mb);
1548
unlock_user_struct(target_mb, msgp, 0);
1549
1550
return ret;
1551
}
1552
1553
static inline long do_msgrcv(long msqid, long msgp, long msgsz, long msgtype, long msgflg)
1554
{
1555
struct target_msgbuf *target_mb;
1556
struct msgbuf *host_mb;
1557
long ret = 0;
1558
1559
lock_user_struct(target_mb, msgp, 0);
1560
host_mb = malloc(msgsz+sizeof(long));
1561
ret = get_errno(msgrcv(msqid, host_mb, msgsz, 1, msgflg));
1562
if (ret > 0)
1563
memcpy(target_mb->mtext, host_mb->mtext, ret);
1564
target_mb->mtype = tswapl(host_mb->mtype);
1565
free(host_mb);
1566
unlock_user_struct(target_mb, msgp, 0);
1567
1568
return ret;
1569
}
1570
1124
1571
/* ??? This only works with linear mappings. */
1125
1572
static long do_ipc(long call, long first, long second, long third,
1126
1573
long ptr, long fifth)
1144
1591
break;
1145
1592
1146
1593
case IPCOP_semctl:
1147
ret = get_errno(semctl(first, second, third, ((union semun*)ptr)->val));
1148
1594
ret = do_semctl(first, second, third, ptr);
1149
1595
break;
1150
1596
1151
1597
case IPCOP_semtimedop:
1158
1604
break;
1159
1605
1160
1606
case IPCOP_msgsnd:
1161
ret = get_errno(msgsnd(first, (struct msgbuf *) ptr, second, third));
1607
ret = do_msgsnd(first, ptr, second, third);
1162
1608
break;
1163
1609
1164
1610
case IPCOP_msgctl:
1165
ret = get_errno(msgctl(first, second, (struct msqid_ds *) ptr));
1611
ret = do_msgctl(first, second, ptr);
1166
1612
break;
1167
1613
1168
1614
case IPCOP_msgrcv:
1169
{
1170
struct ipc_kludge
1171
{
1172
void *__unbounded msgp;
1173
long int msgtyp;
1174
};
1175
1176
struct ipc_kludge *foo = (struct ipc_kludge *) ptr;
1177
struct msgbuf *msgp = (struct msgbuf *) foo->msgp;
1178
1179
ret = get_errno(msgrcv(first, msgp, second, 0, third));
1180
1181
}
1615
{
1616
struct ipc_kludge
1617
{
1618
void *__unbounded msgp;
1619
long int msgtyp;
1620
};
1621
1622
struct ipc_kludge *foo = (struct ipc_kludge *) ptr;
1623
struct msgbuf *msgp = (struct msgbuf *) foo->msgp;
1624
1625
ret = do_msgrcv(first, (long)msgp, second, 0, third);
1626
1627
}
1182
1628
break;
1183
1629
1184
1630
case IPCOP_shmat:
1717
2163
ts->next = first_task_state;
1718
2164
first_task_state = ts;
1719
2165
/* we create a new CPU instance. */
1720
new_env = cpu_init();
1721
memcpy(new_env, env, sizeof(CPUState));
2166
new_env = cpu_copy(env);
1722
2167
#if defined(TARGET_I386)
1723
2168
if (!newsp)
1724
2169
newsp = env->regs[R_ESP];
1743
2188
new_env->dregs[0] = 0;
1744
2189
/* ??? is this sufficient? */
1745
2190
#elif defined(TARGET_MIPS)
1746
printf ("HELPME: %s:%d\n", __FILE__, __LINE__);
2191
if (!newsp)
2192
newsp = env->gpr[29];
2193
new_env->gpr[29] = newsp;
1747
2194
#elif defined(TARGET_PPC)
1748
2195
if (!newsp)
1749
2196
newsp = env->gpr[1];
1758
2205
newsp = env->gregs[15];
1759
2206
new_env->gregs[15] = newsp;
1760
2207
/* XXXXX */
2208
#elif defined(TARGET_ALPHA)
2209
if (!newsp)
2210
newsp = env->ir[30];
2211
new_env->ir[30] = newsp;
2212
/* ? */
2213
{
2214
int i;
2215
for (i = 7; i < 30; i++)
2216
new_env->ir[i] = 0;
2217
}
1761
2218
#else
1762
2219
#error unsupported target CPU
1763
2220
#endif
1786
2243
1787
2244
switch(cmd) {
1788
2245
case TARGET_F_GETLK:
2246
lock_user_struct(target_fl, arg, 1);
2247
fl.l_type = tswap16(target_fl->l_type);
2248
fl.l_whence = tswap16(target_fl->l_whence);
2249
fl.l_start = tswapl(target_fl->l_start);
2250
fl.l_len = tswapl(target_fl->l_len);
2251
fl.l_pid = tswapl(target_fl->l_pid);
2252
unlock_user_struct(target_fl, arg, 0);
1789
2253
ret = fcntl(fd, cmd, &fl);
1790
2254
if (ret == 0) {
1791
2255
lock_user_struct(target_fl, arg, 0);
1811
2275
break;
1812
2276
1813
2277
case TARGET_F_GETLK64:
2278
lock_user_struct(target_fl64, arg, 1);
2279
fl64.l_type = tswap16(target_fl64->l_type) >> 1;
2280
fl64.l_whence = tswap16(target_fl64->l_whence);
2281
fl64.l_start = tswapl(target_fl64->l_start);
2282
fl64.l_len = tswapl(target_fl64->l_len);
2283
fl64.l_pid = tswap16(target_fl64->l_pid);
2284
unlock_user_struct(target_fl64, arg, 0);
1814
2285
ret = fcntl(fd, cmd >> 1, &fl64);
1815
2286
if (ret == 0) {
1816
2287
lock_user_struct(target_fl64, arg, 0);
2036
2507
case TARGET_NR_fork:
2037
2508
ret = get_errno(do_fork(cpu_env, SIGCHLD, 0));
2038
2509
break;
2510
#ifdef TARGET_NR_waitpid
2039
2511
case TARGET_NR_waitpid:
2040
2512
{
2041
2513
int status;
2044
2516
tput32(arg2, status);
2045
2517
}
2046
2518
break;
2519
#endif
2520
#ifdef TARGET_NR_creat /* not on alpha */
2047
2521
case TARGET_NR_creat:
2048
2522
p = lock_user_string(arg1);
2049
2523
ret = get_errno(creat(p, arg2));
2050
2524
unlock_user(p, arg1, 0);
2051
2525
break;
2526
#endif
2052
2527
case TARGET_NR_link:
2053
2528
{
2054
2529
void * p2;
2156
2631
case TARGET_NR_lseek:
2157
2632
ret = get_errno(lseek(arg1, arg2, arg3));
2158
2633
break;
2634
#ifdef TARGET_NR_getxpid
2635
case TARGET_NR_getxpid:
2636
#else
2159
2637
case TARGET_NR_getpid:
2638
#endif
2160
2639
ret = get_errno(getpid());
2161
2640
break;
2162
2641
case TARGET_NR_mount:
2163
/* need to look at the data field */
2164
goto unimplemented;
2642
{
2643
/* need to look at the data field */
2644
void *p2, *p3;
2645
p = lock_user_string(arg1);
2646
p2 = lock_user_string(arg2);
2647
p3 = lock_user_string(arg3);
2648
ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, (const void *)arg5));
2649
unlock_user(p, arg1, 0);
2650
unlock_user(p2, arg2, 0);
2651
unlock_user(p3, arg3, 0);
2652
break;
2653
}
2654
#ifdef TARGET_NR_umount
2165
2655
case TARGET_NR_umount:
2166
2656
p = lock_user_string(arg1);
2167
2657
ret = get_errno(umount(p));
2168
2658
unlock_user(p, arg1, 0);
2169
2659
break;
2660
#endif
2661
#ifdef TARGET_NR_stime /* not on alpha */
2170
2662
case TARGET_NR_stime:
2171
2663
{
2172
2664
time_t host_time;
2174
2666
ret = get_errno(stime(&host_time));
2175
2667
}
2176
2668
break;
2669
#endif
2177
2670
case TARGET_NR_ptrace:
2178
2671
goto unimplemented;
2672
#ifdef TARGET_NR_alarm /* not on alpha */
2179
2673
case TARGET_NR_alarm:
2180
2674
ret = alarm(arg1);
2181
2675
break;
2676
#endif
2182
2677
#ifdef TARGET_NR_oldfstat
2183
2678
case TARGET_NR_oldfstat:
2184
2679
goto unimplemented;
2185
2680
#endif
2681
#ifdef TARGET_NR_pause /* not on alpha */
2186
2682
case TARGET_NR_pause:
2187
2683
ret = get_errno(pause());
2188
2684
break;
2685
#endif
2686
#ifdef TARGET_NR_utime
2189
2687
case TARGET_NR_utime:
2190
2688
{
2191
2689
struct utimbuf tbuf, *host_tbuf;
2204
2702
unlock_user(p, arg1, 0);
2205
2703
}
2206
2704
break;
2705
#endif
2207
2706
case TARGET_NR_utimes:
2208
2707
{
2209
2708
struct timeval *tvp, tv[2];
2233
2732
ret = get_errno(access(p, arg2));
2234
2733
unlock_user(p, arg1, 0);
2235
2734
break;
2735
#ifdef TARGET_NR_nice /* not on alpha */
2236
2736
case TARGET_NR_nice:
2237
2737
ret = get_errno(nice(arg1));
2238
2738
break;
2739
#endif
2239
2740
#ifdef TARGET_NR_ftime
2240
2741
case TARGET_NR_ftime:
2241
2742
goto unimplemented;
2275
2776
int host_pipe[2];
2276
2777
ret = get_errno(pipe(host_pipe));
2277
2778
if (!is_error(ret)) {
2779
#if defined(TARGET_MIPS)
2780
((CPUMIPSState*)cpu_env)->gpr[3] = host_pipe[1];
2781
ret = host_pipe[0];
2782
#else
2278
2783
tput32(arg1, host_pipe[0]);
2279
2784
tput32(arg1 + 4, host_pipe[1]);
2785
#endif
2280
2786
}
2281
2787
}
2282
2788
break;
2300
2806
case TARGET_NR_prof:
2301
2807
goto unimplemented;
2302
2808
#endif
2809
#ifdef TARGET_NR_signal
2303
2810
case TARGET_NR_signal:
2304
2811
goto unimplemented;
2305
2812
#endif
2306
2813
case TARGET_NR_acct:
2307
2814
p = lock_user_string(arg1);
2308
2815
ret = get_errno(acct(path(p)));
2309
2816
unlock_user(p, arg1, 0);
2310
2817
break;
2818
#ifdef TARGET_NR_umount2 /* not on alpha */
2311
2819
case TARGET_NR_umount2:
2312
2820
p = lock_user_string(arg1);
2313
2821
ret = get_errno(umount2(p, arg2));
2314
2822
unlock_user(p, arg1, 0);
2315
2823
break;
2824
#endif
2316
2825
#ifdef TARGET_NR_lock
2317
2826
case TARGET_NR_lock:
2318
2827
goto unimplemented;
2351
2860
case TARGET_NR_dup2:
2352
2861
ret = get_errno(dup2(arg1, arg2));
2353
2862
break;
2863
#ifdef TARGET_NR_getppid /* not on alpha */
2354
2864
case TARGET_NR_getppid:
2355
2865
ret = get_errno(getppid());
2356
2866
break;
2867
#endif
2357
2868
case TARGET_NR_getpgrp:
2358
2869
ret = get_errno(getpgrp());
2359
2870
break;
2360
2871
case TARGET_NR_setsid:
2361
2872
ret = get_errno(setsid());
2362
2873
break;
2874
#ifdef TARGET_NR_sigaction
2363
2875
case TARGET_NR_sigaction:
2364
2876
{
2365
#if !defined(TARGET_MIPS)
2877
#if !defined(TARGET_MIPS)
2366
2878
struct target_old_sigaction *old_act;
2367
2879
struct target_sigaction act, oact, *pact;
2368
2880
if (arg2) {
2385
2897
old_act->sa_restorer = oact.sa_restorer;
2386
2898
unlock_user_struct(old_act, arg3, 1);
2387
2899
}
2388
#else
2900
#else
2389
2901
struct target_sigaction act, oact, *pact, *old_act;
2390
2902
2391
2903
if (arg2) {
2411
2923
old_act->sa_mask.sig[3] = 0;
2412
2924
unlock_user_struct(old_act, arg3, 1);
2413
2925
}
2414
#endif
2926
#endif
2415
2927
}
2416
2928
break;
2929
#endif
2417
2930
case TARGET_NR_rt_sigaction:
2418
2931
{
2419
2932
struct target_sigaction *act;
2434
2947
unlock_user_struct(oact, arg3, 1);
2435
2948
}
2436
2949
break;
2950
#ifdef TARGET_NR_sgetmask /* not on alpha */
2437
2951
case TARGET_NR_sgetmask:
2438
2952
{
2439
2953
sigset_t cur_set;
2443
2957
ret = target_set;
2444
2958
}
2445
2959
break;
2960
#endif
2961
#ifdef TARGET_NR_ssetmask /* not on alpha */
2446
2962
case TARGET_NR_ssetmask:
2447
2963
{
2448
2964
sigset_t set, oset, cur_set;
2455
2971
ret = target_set;
2456
2972
}
2457
2973
break;
2974
#endif
2975
#ifdef TARGET_NR_sigprocmask
2458
2976
case TARGET_NR_sigprocmask:
2459
2977
{
2460
2978
int how = arg1;
2491
3009
}
2492
3010
}
2493
3011
break;
3012
#endif
2494
3013
case TARGET_NR_rt_sigprocmask:
2495
3014
{
2496
3015
int how = arg1;
2527
3046
}
2528
3047
}
2529
3048
break;
3049
#ifdef TARGET_NR_sigpending
2530
3050
case TARGET_NR_sigpending:
2531
3051
{
2532
3052
sigset_t set;
2538
3058
}
2539
3059
}
2540
3060
break;
3061
#endif
2541
3062
case TARGET_NR_rt_sigpending:
2542
3063
{
2543
3064
sigset_t set;
2549
3070
}
2550
3071
}
2551
3072
break;
3073
#ifdef TARGET_NR_sigsuspend
2552
3074
case TARGET_NR_sigsuspend:
2553
3075
{
2554
3076
sigset_t set;
2558
3080
ret = get_errno(sigsuspend(&set));
2559
3081
}
2560
3082
break;
3083
#endif
2561
3084
case TARGET_NR_rt_sigsuspend:
2562
3085
{
2563
3086
sigset_t set;
2599
3122
ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
2600
3123
}
2601
3124
break;
3125
#ifdef TARGET_NR_sigreturn
2602
3126
case TARGET_NR_sigreturn:
2603
3127
/* NOTE: ret is eax, so not transcoding must be done */
2604
3128
ret = do_sigreturn(cpu_env);
2605
3129
break;
3130
#endif
2606
3131
case TARGET_NR_rt_sigreturn:
2607
3132
/* NOTE: ret is eax, so not transcoding must be done */
2608
3133
ret = do_rt_sigreturn(cpu_env);
2708
3233
unlock_user(p, arg1, 0);
2709
3234
}
2710
3235
break;
3236
#ifdef TARGET_NR_uselib
2711
3237
case TARGET_NR_uselib:
2712
3238
goto unimplemented;
3239
#endif
3240
#ifdef TARGET_NR_swapon
2713
3241
case TARGET_NR_swapon:
2714
3242
p = lock_user_string(arg1);
2715
3243
ret = get_errno(swapon(p, arg2));
2716
3244
unlock_user(p, arg1, 0);
2717
3245
break;
3246
#endif
2718
3247
case TARGET_NR_reboot:
2719
3248
goto unimplemented;
3249
#ifdef TARGET_NR_readdir
2720
3250
case TARGET_NR_readdir:
2721
3251
goto unimplemented;
3252
#endif
3253
#ifdef TARGET_NR_mmap
2722
3254
case TARGET_NR_mmap:
2723
3255
#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_M68K)
2724
3256
{
2743
3275
arg6));
2744
3276
#endif
2745
3277
break;
3278
#endif
2746
3279
#ifdef TARGET_NR_mmap2
2747
3280
case TARGET_NR_mmap2:
2748
3281
#if defined(TARGET_SPARC) || defined(TARGET_MIPS)
2762
3295
case TARGET_NR_mprotect:
2763
3296
ret = get_errno(target_mprotect(arg1, arg2, arg3));
2764
3297
break;
3298
#ifdef TARGET_NR_mremap
2765
3299
case TARGET_NR_mremap:
2766
3300
ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
2767
3301
break;
3302
#endif
2768
3303
/* ??? msync/mlock/munlock are broken for softmmu. */
3304
#ifdef TARGET_NR_msync
2769
3305
case TARGET_NR_msync:
2770
3306
ret = get_errno(msync(g2h(arg1), arg2, arg3));
2771
3307
break;
3308
#endif
3309
#ifdef TARGET_NR_mlock
2772
3310
case TARGET_NR_mlock:
2773
3311
ret = get_errno(mlock(g2h(arg1), arg2));
2774
3312
break;
3313
#endif
3314
#ifdef TARGET_NR_munlock
2775
3315
case TARGET_NR_munlock:
2776
3316
ret = get_errno(munlock(g2h(arg1), arg2));
2777
3317
break;
3318
#endif
3319
#ifdef TARGET_NR_mlockall
2778
3320
case TARGET_NR_mlockall:
2779
3321
ret = get_errno(mlockall(arg1));
2780
3322
break;
3323
#endif
3324
#ifdef TARGET_NR_munlockall
2781
3325
case TARGET_NR_munlockall:
2782
3326
ret = get_errno(munlockall());
2783
3327
break;
3328
#endif
2784
3329
case TARGET_NR_truncate:
2785
3330
p = lock_user_string(arg1);
2786
3331
ret = get_errno(truncate(p, arg2));
2819
3364
put_user(stfs.f_bavail, &target_stfs->f_bavail);
2820
3365
put_user(stfs.f_files, &target_stfs->f_files);
2821
3366
put_user(stfs.f_ffree, &target_stfs->f_ffree);
2822
put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid);
3367
put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
3368
put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
2823
3369
put_user(stfs.f_namelen, &target_stfs->f_namelen);
2824
3370
unlock_user_struct(target_stfs, arg2, 1);
2825
3371
}
2845
3391
put_user(stfs.f_bavail, &target_stfs->f_bavail);
2846
3392
put_user(stfs.f_files, &target_stfs->f_files);
2847
3393
put_user(stfs.f_ffree, &target_stfs->f_ffree);
2848
put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid);
3394
put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
3395
put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
2849
3396
put_user(stfs.f_namelen, &target_stfs->f_namelen);
2850
3397
unlock_user_struct(target_stfs, arg3, 0);
2851
3398
}
2858
3405
case TARGET_NR_ioperm:
2859
3406
goto unimplemented;
2860
3407
#endif
3408
#ifdef TARGET_NR_socketcall
2861
3409
case TARGET_NR_socketcall:
2862
3410
ret = do_socketcall(arg1, arg2);
2863
3411
break;
2864
3412
#endif
2865
3413
#ifdef TARGET_NR_accept
2866
3414
case TARGET_NR_accept:
2867
3415
ret = do_accept(arg1, arg2, arg3);
2899
3447
#endif
2900
3448
#ifdef TARGET_NR_recv
2901
3449
case TARGET_NR_recv:
2902
ret = do_recvfrom(arg1, arg1, arg3, arg4, 0, 0);
3450
ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
2903
3451
break;
2904
3452
#endif
2905
3453
#ifdef TARGET_NR_recvfrom
2906
3454
case TARGET_NR_recvfrom:
2907
ret = do_recvfrom(arg1, arg1, arg3, arg4, arg5, arg6);
3455
ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
2908
3456
break;
2909
3457
#endif
2910
3458
#ifdef TARGET_NR_recvmsg
2947
3495
ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
2948
3496
break;
2949
3497
#endif
2950
3498
2951
3499
case TARGET_NR_syslog:
2952
goto unimplemented;
3500
p = lock_user_string(arg2);
3501
ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
3502
unlock_user(p, arg2, 0);
3503
break;
3504
2953
3505
case TARGET_NR_setitimer:
2954
3506
{
2955
3507
struct itimerval value, ovalue, *pvalue;
3001
3553
do_stat:
3002
3554
if (!is_error(ret)) {
3003
3555
struct target_stat *target_st;
3004
3556
3005
3557
lock_user_struct(target_st, arg2, 0);
3558
#if defined(TARGET_MIPS) || defined(TARGET_SPARC64)
3559
target_st->st_dev = tswap32(st.st_dev);
3560
#else
3006
3561
target_st->st_dev = tswap16(st.st_dev);
3562
#endif
3007
3563
target_st->st_ino = tswapl(st.st_ino);
3008
3564
#if defined(TARGET_PPC) || defined(TARGET_MIPS)
3009
3565
target_st->st_mode = tswapl(st.st_mode); /* XXX: check this */
3010
3566
target_st->st_uid = tswap32(st.st_uid);
3011
3567
target_st->st_gid = tswap32(st.st_gid);
3568
#elif defined(TARGET_SPARC64)
3569
target_st->st_mode = tswap32(st.st_mode);
3570
target_st->st_uid = tswap32(st.st_uid);
3571
target_st->st_gid = tswap32(st.st_gid);
3012
3572
#else
3013
3573
target_st->st_mode = tswap16(st.st_mode);
3014
3574
target_st->st_uid = tswap16(st.st_uid);
3015
3575
target_st->st_gid = tswap16(st.st_gid);
3016
3576
#endif
3577
#if defined(TARGET_MIPS)
3578
/* If this is the same on PPC, then just merge w/ the above ifdef */
3579
target_st->st_nlink = tswapl(st.st_nlink);
3580
target_st->st_rdev = tswapl(st.st_rdev);
3581
#elif defined(TARGET_SPARC64)
3582
target_st->st_nlink = tswap32(st.st_nlink);
3583
target_st->st_rdev = tswap32(st.st_rdev);
3584
#else
3017
3585
target_st->st_nlink = tswap16(st.st_nlink);
3018
3586
target_st->st_rdev = tswap16(st.st_rdev);
3587
#endif
3019
3588
target_st->st_size = tswapl(st.st_size);
3020
3589
target_st->st_blksize = tswapl(st.st_blksize);
3021
3590
target_st->st_blocks = tswapl(st.st_blocks);
3066
3635
}
3067
3636
}
3068
3637
break;
3638
#ifdef TARGET_NR_swapoff
3069
3639
case TARGET_NR_swapoff:
3070
3640
p = lock_user_string(arg1);
3071
3641
ret = get_errno(swapoff(p));
3072
3642
unlock_user(p, arg1, 0);
3073
3643
break;
3644
#endif
3074
3645
case TARGET_NR_sysinfo:
3075
3646
{
3076
3647
struct target_sysinfo *target_value;
3098
3669
}
3099
3670
}
3100
3671
break;
3672
#ifdef TARGET_NR_ipc
3101
3673
case TARGET_NR_ipc:
3102
3674
ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
3103
3675
break;
3676
#endif
3104
3677
case TARGET_NR_fsync:
3105
3678
ret = get_errno(fsync(arg1));
3106
3679
break;
3141
3714
case TARGET_NR_modify_ldt:
3142
3715
ret = get_errno(do_modify_ldt(cpu_env, arg1, arg2, arg3));
3143
3716
break;
3717
#if !defined(TARGET_X86_64)
3144
3718
case TARGET_NR_vm86old:
3145
3719
goto unimplemented;
3146
3720
case TARGET_NR_vm86:
3147
3721
ret = do_vm86(cpu_env, arg1, arg2);
3148
3722
break;
3149
3723
#endif
3724
#endif
3150
3725
case TARGET_NR_adjtimex:
3151
3726
goto unimplemented;
3727
#ifdef TARGET_NR_create_module
3152
3728
case TARGET_NR_create_module:
3729
#endif
3153
3730
case TARGET_NR_init_module:
3154
3731
case TARGET_NR_delete_module:
3732
#ifdef TARGET_NR_get_kernel_syms
3155
3733
case TARGET_NR_get_kernel_syms:
3734
#endif
3156
3735
goto unimplemented;
3157
3736
case TARGET_NR_quotactl:
3158
3737
goto unimplemented;
3162
3741
case TARGET_NR_fchdir:
3163
3742
ret = get_errno(fchdir(arg1));
3164
3743
break;
3744
#ifdef TARGET_NR_bdflush /* not on x86_64 */
3165
3745
case TARGET_NR_bdflush:
3166
3746
goto unimplemented;
3747
#endif
3748
#ifdef TARGET_NR_sysfs
3167
3749
case TARGET_NR_sysfs:
3168
3750
goto unimplemented;
3751
#endif
3169
3752
case TARGET_NR_personality:
3170
3753
ret = get_errno(personality(arg1));
3171
3754
break;
3755
#ifdef TARGET_NR_afs_syscall
3172
3756
case TARGET_NR_afs_syscall:
3173
3757
goto unimplemented;
3758
#endif
3759
#ifdef TARGET_NR__llseek /* Not on alpha */
3174
3760
case TARGET_NR__llseek:
3175
3761
{
3176
3762
#if defined (__x86_64__)
3183
3769
#endif
3184
3770
}
3185
3771
break;
3772
#endif
3186
3773
case TARGET_NR_getdents:
3187
3774
#if TARGET_LONG_SIZE != 4
3188
3775
goto unimplemented;
3222
3809
strncpy(tde->d_name, de->d_name, tnamelen);
3223
3810
de = (struct dirent *)((char *)de + reclen);
3224
3811
len -= reclen;
3225
tde = (struct dirent *)((char *)tde + treclen);
3812
tde = (struct target_dirent *)((char *)tde + treclen);
3226
3813
count1 += treclen;
3227
3814
}
3228
3815
ret = count1;
3284
3871
}
3285
3872
break;
3286
3873
#endif /* TARGET_NR_getdents64 */
3874
#ifdef TARGET_NR__newselect
3287
3875
case TARGET_NR__newselect:
3288
3876
ret = do_select(arg1, arg2, arg3, arg4, arg5);
3289
3877
break;
3878
#endif
3879
#ifdef TARGET_NR_poll
3290
3880
case TARGET_NR_poll:
3291
3881
{
3292
3882
struct target_pollfd *target_pfd;
3312
3902
unlock_user(target_pfd, arg1, ret);
3313
3903
}
3314
3904
break;
3905
#endif
3315
3906
case TARGET_NR_flock:
3316
3907
/* NOTE: the flock constant seems to be the same for every
3317
3908
Linux platform */
3342
3933
case TARGET_NR_getsid:
3343
3934
ret = get_errno(getsid(arg1));
3344
3935
break;
3936
#if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
3345
3937
case TARGET_NR_fdatasync:
3346
3938
ret = get_errno(fdatasync(arg1));
3347
3939
break;
3940
#endif
3348
3941
case TARGET_NR__sysctl:
3349
3942
/* We don't implement this, but ENODIR is always a safe
3350
3943
return value. */
3413
4006
}
3414
4007
}
3415
4008
break;
4009
#ifdef TARGET_NR_query_module
3416
4010
case TARGET_NR_query_module:
3417
4011
goto unimplemented;
4012
#endif
4013
#ifdef TARGET_NR_nfsservctl
3418
4014
case TARGET_NR_nfsservctl:
3419
4015
goto unimplemented;
4016
#endif
3420
4017
case TARGET_NR_prctl:
3421
goto unimplemented;
4018
switch (arg1)
4019
{
4020
case PR_GET_PDEATHSIG:
4021
{
4022
int deathsig;
4023
ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
4024
if (!is_error(ret) && arg2)
4025
tput32(arg2, deathsig);
4026
}
4027
break;
4028
default:
4029
ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
4030
break;
4031
}
4032
break;
3422
4033
#ifdef TARGET_NR_pread
3423
4034
case TARGET_NR_pread:
3424
4035
page_unprotect_range(arg2, arg3);
3837
4448
#if TARGET_LONG_BITS == 32
3838
4449
case TARGET_NR_fcntl64:
3839
4450
{
4451
int cmd;
3840
4452
struct flock64 fl;
3841
4453
struct target_flock64 *target_fl;
3842
4454
#ifdef TARGET_ARM
3843
4455
struct target_eabi_flock64 *target_efl;
3844
4456
#endif
3845
4457
4458
switch(arg2){
4459
case TARGET_F_GETLK64:
4460
cmd = F_GETLK64;
4461
break;
4462
case TARGET_F_SETLK64:
4463
cmd = F_SETLK64;
4464
break;
4465
case TARGET_F_SETLKW64:
4466
cmd = F_SETLK64;
4467
break;
4468
default:
4469
cmd = arg2;
4470
break;
4471
}
4472
3846
4473
switch(arg2) {
3847
case F_GETLK64:
3848
ret = get_errno(fcntl(arg1, arg2, &fl));
4474
case TARGET_F_GETLK64:
4475
#ifdef TARGET_ARM
4476
if (((CPUARMState *)cpu_env)->eabi) {
4477
lock_user_struct(target_efl, arg3, 1);
4478
fl.l_type = tswap16(target_efl->l_type);
4479
fl.l_whence = tswap16(target_efl->l_whence);
4480
fl.l_start = tswap64(target_efl->l_start);
4481
fl.l_len = tswap64(target_efl->l_len);
4482
fl.l_pid = tswapl(target_efl->l_pid);
4483
unlock_user_struct(target_efl, arg3, 0);
4484
} else
4485
#endif
4486
{
4487
lock_user_struct(target_fl, arg3, 1);
4488
fl.l_type = tswap16(target_fl->l_type);
4489
fl.l_whence = tswap16(target_fl->l_whence);
4490
fl.l_start = tswap64(target_fl->l_start);
4491
fl.l_len = tswap64(target_fl->l_len);
4492
fl.l_pid = tswapl(target_fl->l_pid);
4493
unlock_user_struct(target_fl, arg3, 0);
4494
}
4495
ret = get_errno(fcntl(arg1, cmd, &fl));
3849
4496
if (ret == 0) {
3850
4497
#ifdef TARGET_ARM
3851
4498
if (((CPUARMState *)cpu_env)->eabi) {
3870
4517
}
3871
4518
break;
3872
4519
3873
case F_SETLK64:
3874
case F_SETLKW64:
4520
case TARGET_F_SETLK64:
4521
case TARGET_F_SETLKW64:
3875
4522
#ifdef TARGET_ARM
3876
4523
if (((CPUARMState *)cpu_env)->eabi) {
3877
4524
lock_user_struct(target_efl, arg3, 1);
3892
4539
fl.l_pid = tswapl(target_fl->l_pid);
3893
4540
unlock_user_struct(target_fl, arg3, 0);
3894
4541
}
3895
ret = get_errno(fcntl(arg1, arg2, &fl));
4542
ret = get_errno(fcntl(arg1, cmd, &fl));
3896
4543
break;
3897
4544
default:
3898
ret = get_errno(do_fcntl(arg1, arg2, arg3));
4545
ret = get_errno(do_fcntl(arg1, cmd, arg3));
3899
4546
break;
3900
4547
}
3901
4548
break;
3919
4566
case TARGET_NR_gettid:
3920
4567
ret = get_errno(gettid());
3921
4568
break;
4569
#ifdef TARGET_NR_readahead
3922
4570
case TARGET_NR_readahead:
3923
4571
goto unimplemented;
4572
#endif
3924
4573
#ifdef TARGET_NR_setxattr
3925
4574
case TARGET_NR_setxattr:
3926
4575
case TARGET_NR_lsetxattr:
3938
4587
#endif
3939
4588
#ifdef TARGET_NR_set_thread_area
3940
4589
case TARGET_NR_set_thread_area:
4590
#ifdef TARGET_MIPS
4591
((CPUMIPSState *) cpu_env)->tls_value = arg1;
4592
ret = 0;
4593
break;
4594
#else
4595
goto unimplemented_nowarn;
4596
#endif
4597
#endif
4598
#ifdef TARGET_NR_get_thread_area
3941
4599
case TARGET_NR_get_thread_area:
3942
4600
goto unimplemented_nowarn;
3943
4601
#endif
3945
4603
case TARGET_NR_getdomainname:
3946
4604
goto unimplemented_nowarn;
3947
4605
#endif
4606
4607
#ifdef TARGET_NR_clock_gettime
4608
case TARGET_NR_clock_gettime:
4609
{
4610
struct timespec ts;
4611
ret = get_errno(clock_gettime(arg1, &ts));
4612
if (!is_error(ret)) {
4613
host_to_target_timespec(arg2, &ts);
4614
}
4615
break;
4616
}
4617
#endif
4618
#ifdef TARGET_NR_clock_getres
4619
case TARGET_NR_clock_getres:
4620
{
4621
struct timespec ts;
4622
ret = get_errno(clock_getres(arg1, &ts));
4623
if (!is_error(ret)) {
4624
host_to_target_timespec(arg2, &ts);
4625
}
4626
break;
4627
}
4628
#endif
4629
4630
#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
4631
case TARGET_NR_set_tid_address:
4632
ret = get_errno(set_tid_address((int *) arg1));
4633
break;
4634
#endif
4635
4636
#ifdef TARGET_NR_tkill
4637
case TARGET_NR_tkill:
4638
ret = get_errno(sys_tkill((int)arg1, (int)arg2));
4639
break;
4640
#endif
4641
4642
#ifdef TARGET_NR_tgkill
4643
case TARGET_NR_tgkill:
4644
ret = get_errno(sys_tgkill((int)arg1, (int)arg2, (int)arg3));
4645
break;
4646
#endif
4647
4648
#ifdef TARGET_NR_set_robust_list
4649
case TARGET_NR_set_robust_list:
4650
goto unimplemented_nowarn;
4651
#endif
4652
3948
4653
default:
3949
4654
unimplemented:
3950
4655
gemu_log("qemu: Unsupported syscall: %d\n", num);
3951
#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_set_thread_area) || defined(TARGET_NR_getdomainname)
4656
#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
3952
4657
unimplemented_nowarn:
3953
4658
#endif
3954
4659
ret = -ENOSYS;
Loggerhead is a web-based interface for Breezy
Version: 2.0.1