granicus.if.org Git - strace/blob - ipc.c

   1 /*
   2  * Copyright (c) 1993 Ulrich Pegelow <pegelow@moorea.uni-muenster.de>
   3  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
   4  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
   5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  *      $Id$
  31  */
  32
  33 #include "defs.h"
  34
  35 #if defined(LINUX) || defined(SUNOS4) || defined(FREEBSD)
  36
  37 # ifdef HAVE_MQUEUE_H
  38 #  include <mqueue.h>
  39 # endif
  40
  41 #include <fcntl.h>
  42 #include <sys/ipc.h>
  43 #include <sys/sem.h>
  44 #include <sys/msg.h>
  45 #include <sys/shm.h>
  46
  47 #ifndef MSG_STAT
  48 #define MSG_STAT 11
  49 #endif
  50 #ifndef MSG_INFO
  51 #define MSG_INFO 12
  52 #endif
  53 #ifndef SHM_STAT
  54 #define SHM_STAT 13
  55 #endif
  56 #ifndef SHM_INFO
  57 #define SHM_INFO 14
  58 #endif
  59 #ifndef SEM_STAT
  60 #define SEM_STAT 18
  61 #endif
  62 #ifndef SEM_INFO
  63 #define SEM_INFO 19
  64 #endif
  65
  66 #if defined LINUX && !defined IPC_64
  67 # define IPC_64 0x100
  68 #endif
  69
  70 extern void printsigevent(struct tcb *tcp, long arg);
  71
  72 static const struct xlat msgctl_flags[] = {
  73         { IPC_RMID,     "IPC_RMID"      },
  74         { IPC_SET,      "IPC_SET"       },
  75         { IPC_STAT,     "IPC_STAT"      },
  76 #ifdef LINUX
  77         { IPC_INFO,     "IPC_INFO"      },
  78         { MSG_STAT,     "MSG_STAT"      },
  79         { MSG_INFO,     "MSG_INFO"      },
  80 #endif /* LINUX */
  81         { 0,            NULL            },
  82 };
  83
  84 static const struct xlat semctl_flags[] = {
  85         { IPC_RMID,     "IPC_RMID"      },
  86         { IPC_SET,      "IPC_SET"       },
  87         { IPC_STAT,     "IPC_STAT"      },
  88 #ifdef LINUX
  89         { IPC_INFO,     "IPC_INFO"      },
  90         { SEM_STAT,     "SEM_STAT"      },
  91         { SEM_INFO,     "SEM_INFO"      },
  92 #endif /* LINUX */
  93         { GETPID,       "GETPID"        },
  94         { GETVAL,       "GETVAL"        },
  95         { GETALL,       "GETALL"        },
  96         { GETNCNT,      "GETNCNT"       },
  97         { GETZCNT,      "GETZCNT"       },
  98         { SETVAL,       "SETVAL"        },
  99         { SETALL,       "SETALL"        },
 100         { 0,            NULL            },
 101 };
 102
 103 static const struct xlat shmctl_flags[] = {
 104         { IPC_RMID,     "IPC_RMID"      },
 105         { IPC_SET,      "IPC_SET"       },
 106         { IPC_STAT,     "IPC_STAT"      },
 107 #ifdef LINUX
 108         { IPC_INFO,     "IPC_INFO"      },
 109         { SHM_STAT,     "SHM_STAT"      },
 110         { SHM_INFO,     "SHM_INFO"      },
 111 #endif /* LINUX */
 112 #ifdef SHM_LOCK
 113         { SHM_LOCK,     "SHM_LOCK"      },
 114 #endif
 115 #ifdef SHM_UNLOCK
 116         { SHM_UNLOCK,   "SHM_UNLOCK"    },
 117 #endif
 118         { 0,            NULL            },
 119 };
 120
 121 static const struct xlat resource_flags[] = {
 122         { IPC_CREAT,    "IPC_CREAT"     },
 123         { IPC_EXCL,     "IPC_EXCL"      },
 124         { IPC_NOWAIT,   "IPC_NOWAIT"    },
 125         { 0,            NULL            },
 126 };
 127
 128 static const struct xlat shm_resource_flags[] = {
 129         { IPC_CREAT,    "IPC_CREAT"     },
 130         { IPC_EXCL,     "IPC_EXCL"      },
 131 #ifdef SHM_HUGETLB
 132         { SHM_HUGETLB,  "SHM_HUGETLB"   },
 133 #endif
 134         { 0,            NULL            },
 135 };
 136
 137 static const struct xlat shm_flags[] = {
 138 #ifdef LINUX
 139         { SHM_REMAP,    "SHM_REMAP"     },
 140 #endif /* LINUX */
 141         { SHM_RDONLY,   "SHM_RDONLY"    },
 142         { SHM_RND,      "SHM_RND"       },
 143         { 0,            NULL            },
 144 };
 145
 146 static const struct xlat msg_flags[] = {
 147         { MSG_NOERROR,  "MSG_NOERROR"   },
 148 #ifdef LINUX
 149         { MSG_EXCEPT,   "MSG_EXCEPT"    },
 150 #endif /* LINUX */
 151         { IPC_NOWAIT,   "IPC_NOWAIT"    },
 152         { 0,            NULL            },
 153 };
 154
 155 static const struct xlat semop_flags[] = {
 156         { SEM_UNDO,     "SEM_UNDO"      },
 157         { IPC_NOWAIT,   "IPC_NOWAIT"    },
 158         { 0,            NULL            },
 159 };
 160
 161 int sys_msgget(struct tcb *tcp)
 162 {
 163         if (entering(tcp)) {
 164                 if (tcp->u_arg[0])
 165                         tprintf("%#lx", tcp->u_arg[0]);
 166                 else
 167                         tprints("IPC_PRIVATE");
 168                 tprints(", ");
 169                 if (printflags(resource_flags, tcp->u_arg[1] & ~0777, NULL) != 0)
 170                         tprints("|");
 171                 tprintf("%#lo", tcp->u_arg[1] & 0777);
 172         }
 173         return 0;
 174 }
 175
 176 #ifdef IPC_64
 177 # define PRINTCTL(flagset, arg, dflt) \
 178         if ((arg) & IPC_64) tprints("IPC_64|"); \
 179         printxval((flagset), (arg) &~ IPC_64, dflt)
 180 #else
 181 # define PRINTCTL printxval
 182 #endif
 183
 184 static int
 185 indirect_ipccall(struct tcb *tcp)
 186 {
 187 #ifdef LINUX
 188 #ifdef X86_64
 189         return current_personality > 0;
 190 #endif
 191 #if defined IA64
 192         return tcp->scno < 1024; /* ia32 emulation syscalls are low */
 193 #endif
 194 #if !defined MIPS && !defined HPPA
 195         return 1;
 196 #endif
 197 #endif  /* LINUX */
 198         return 0;
 199 }
 200
 201 int sys_msgctl(struct tcb *tcp)
 202 {
 203         if (entering(tcp)) {
 204                 tprintf("%lu, ", tcp->u_arg[0]);
 205                 PRINTCTL(msgctl_flags, tcp->u_arg[1], "MSG_???");
 206                 tprintf(", %#lx", tcp->u_arg[indirect_ipccall(tcp) ? 3 : 2]);
 207         }
 208         return 0;
 209 }
 210
 211 static void
 212 tprint_msgsnd(struct tcb *tcp, long addr, unsigned long count,
 213               unsigned long flags)
 214 {
 215         long mtype;
 216
 217         if (umove(tcp, addr, &mtype) < 0) {
 218                 tprintf("%#lx", addr);
 219         } else {
 220                 tprintf("{%lu, ", mtype);
 221                 printstr(tcp, addr + sizeof(mtype), count);
 222                 tprints("}");
 223         }
 224         tprintf(", %lu, ", count);
 225         printflags(msg_flags, flags, "MSG_???");
 226 }
 227
 228 int sys_msgsnd(struct tcb *tcp)
 229 {
 230         if (entering(tcp)) {
 231                 tprintf("%d, ", (int) tcp->u_arg[0]);
 232                 if (indirect_ipccall(tcp)) {
 233                         tprint_msgsnd(tcp, tcp->u_arg[3], tcp->u_arg[1],
 234                                       tcp->u_arg[2]);
 235                 } else {
 236                         tprint_msgsnd(tcp, tcp->u_arg[1], tcp->u_arg[2],
 237                                       tcp->u_arg[3]);
 238                 }
 239         }
 240         return 0;
 241 }
 242
 243 static void
 244 tprint_msgrcv(struct tcb *tcp, long addr, unsigned long count, long msgtyp)
 245 {
 246         long mtype;
 247
 248         if (syserror(tcp) || umove(tcp, addr, &mtype) < 0) {
 249                 tprintf("%#lx", addr);
 250         } else {
 251                 tprintf("{%lu, ", mtype);
 252                 printstr(tcp, addr + sizeof(mtype), count);
 253                 tprints("}");
 254         }
 255         tprintf(", %lu, %ld, ", count, msgtyp);
 256 }
 257
 258 int sys_msgrcv(struct tcb *tcp)
 259 {
 260         if (entering(tcp)) {
 261                 tprintf("%d, ", (int) tcp->u_arg[0]);
 262         } else {
 263                 if (indirect_ipccall(tcp)) {
 264                         struct ipc_wrapper {
 265                                 struct msgbuf *msgp;
 266                                 long msgtyp;
 267                         } tmp;
 268
 269                         if (umove(tcp, tcp->u_arg[3], &tmp) < 0) {
 270                                 tprintf("%#lx, %lu, ",
 271                                         tcp->u_arg[3], tcp->u_arg[1]);
 272                         } else {
 273                                 tprint_msgrcv(tcp, (long) tmp.msgp,
 274                                         tcp->u_arg[1], tmp.msgtyp);
 275                         }
 276                         printflags(msg_flags, tcp->u_arg[2], "MSG_???");
 277                 } else {
 278                         tprint_msgrcv(tcp, tcp->u_arg[1],
 279                                 tcp->u_arg[2], tcp->u_arg[3]);
 280                         printflags(msg_flags, tcp->u_arg[4], "MSG_???");
 281                 }
 282         }
 283         return 0;
 284 }
 285
 286 static void
 287 tprint_sembuf(struct tcb *tcp, long addr, unsigned long count)
 288 {
 289         unsigned long i, max_count;
 290
 291         if (abbrev(tcp))
 292                 max_count = (max_strlen < count) ? max_strlen : count;
 293         else
 294                 max_count = count;
 295
 296         if (!max_count) {
 297                 tprintf("%#lx, %lu", addr, count);
 298                 return;
 299         }
 300
 301         for (i = 0; i < max_count; ++i) {
 302                 struct sembuf sb;
 303                 if (i)
 304                         tprints(", ");
 305                 if (umove(tcp, addr + i * sizeof(struct sembuf), &sb) < 0) {
 306                         if (i) {
 307                                 tprints("{???}");
 308                                 break;
 309                         } else {
 310                                 tprintf("%#lx, %lu", addr, count);
 311                                 return;
 312                         }
 313                 } else {
 314                         if (!i)
 315                                 tprints("{");
 316                         tprintf("{%u, %d, ", sb.sem_num, sb.sem_op);
 317                         printflags(semop_flags, sb.sem_flg, "SEM_???");
 318                         tprints("}");
 319                 }
 320         }
 321
 322         if (i < max_count || max_count < count)
 323                 tprints(", ...");
 324
 325         tprintf("}, %lu", count);
 326 }
 327
 328 int sys_semop(struct tcb *tcp)
 329 {
 330         if (entering(tcp)) {
 331                 tprintf("%lu, ", tcp->u_arg[0]);
 332                 if (indirect_ipccall(tcp)) {
 333                         tprint_sembuf(tcp, tcp->u_arg[3], tcp->u_arg[1]);
 334                 } else {
 335                         tprint_sembuf(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 336                 }
 337         }
 338         return 0;
 339 }
 340
 341 #ifdef LINUX
 342 int sys_semtimedop(struct tcb *tcp)
 343 {
 344         if (entering(tcp)) {
 345                 tprintf("%lu, ", tcp->u_arg[0]);
 346                 if (indirect_ipccall(tcp)) {
 347                         tprint_sembuf(tcp, tcp->u_arg[3], tcp->u_arg[1]);
 348                         tprints(", ");
 349 #if defined(S390)
 350                         printtv(tcp, tcp->u_arg[2]);
 351 #else
 352                         printtv(tcp, tcp->u_arg[5]);
 353 #endif
 354                 } else {
 355                         tprint_sembuf(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 356                         tprints(", ");
 357                         printtv(tcp, tcp->u_arg[3]);
 358                 }
 359         }
 360         return 0;
 361 }
 362 #endif
 363
 364 int sys_semget(struct tcb *tcp)
 365 {
 366         if (entering(tcp)) {
 367                 if (tcp->u_arg[0])
 368                         tprintf("%#lx", tcp->u_arg[0]);
 369                 else
 370                         tprints("IPC_PRIVATE");
 371                 tprintf(", %lu", tcp->u_arg[1]);
 372                 tprints(", ");
 373                 if (printflags(resource_flags, tcp->u_arg[2] & ~0777, NULL) != 0)
 374                         tprints("|");
 375                 tprintf("%#lo", tcp->u_arg[2] & 0777);
 376         }
 377         return 0;
 378 }
 379
 380 int sys_semctl(struct tcb *tcp)
 381 {
 382         if (entering(tcp)) {
 383                 tprintf("%lu", tcp->u_arg[0]);
 384                 tprintf(", %lu, ", tcp->u_arg[1]);
 385                 PRINTCTL(semctl_flags, tcp->u_arg[2], "SEM_???");
 386                 tprintf(", %#lx", tcp->u_arg[3]);
 387         }
 388         return 0;
 389 }
 390
 391 int sys_shmget(struct tcb *tcp)
 392 {
 393         if (entering(tcp)) {
 394                 if (tcp->u_arg[0])
 395                         tprintf("%#lx", tcp->u_arg[0]);
 396                 else
 397                         tprints("IPC_PRIVATE");
 398                 tprintf(", %lu", tcp->u_arg[1]);
 399                 tprints(", ");
 400                 if (printflags(shm_resource_flags, tcp->u_arg[2] & ~0777, NULL) != 0)
 401                         tprints("|");
 402                 tprintf("%#lo", tcp->u_arg[2] & 0777);
 403         }
 404         return 0;
 405 }
 406
 407 int sys_shmctl(struct tcb *tcp)
 408 {
 409         if (entering(tcp)) {
 410                 tprintf("%lu, ", tcp->u_arg[0]);
 411                 PRINTCTL(shmctl_flags, tcp->u_arg[1], "SHM_???");
 412                 if (indirect_ipccall(tcp)) {
 413                         tprintf(", %#lx", tcp->u_arg[3]);
 414                 } else {
 415                         tprintf(", %#lx", tcp->u_arg[2]);
 416                 }
 417         }
 418         return 0;
 419 }
 420
 421 int sys_shmat(struct tcb *tcp)
 422 {
 423 #ifdef LINUX
 424         unsigned long raddr;
 425 #endif /* LINUX */
 426
 427         if (exiting(tcp)) {
 428                 tprintf("%lu", tcp->u_arg[0]);
 429                 if (indirect_ipccall(tcp)) {
 430                         tprintf(", %#lx", tcp->u_arg[3]);
 431                         tprints(", ");
 432                         printflags(shm_flags, tcp->u_arg[1], "SHM_???");
 433                 } else {
 434                         tprintf(", %#lx", tcp->u_arg[1]);
 435                         tprints(", ");
 436                         printflags(shm_flags, tcp->u_arg[2], "SHM_???");
 437                 }
 438                 if (syserror(tcp))
 439                         return 0;
 440 /* HPPA does not use an IPC multiplexer on Linux.  */
 441 #if defined(LINUX) && !defined(HPPA)
 442                 if (umove(tcp, tcp->u_arg[2], &raddr) < 0)
 443                         return RVAL_NONE;
 444                 tcp->u_rval = raddr;
 445 #endif /* LINUX */
 446                 return RVAL_HEX;
 447         }
 448         return 0;
 449 }
 450
 451 int sys_shmdt(struct tcb *tcp)
 452 {
 453         if (entering(tcp)) {
 454                 if (indirect_ipccall(tcp)) {
 455                         tprintf("%#lx", tcp->u_arg[3]);
 456                 } else {
 457                         tprintf("%#lx", tcp->u_arg[0]);
 458                 }
 459         }
 460         return 0;
 461 }
 462
 463 #endif /* defined(LINUX) || defined(SUNOS4) || defined(FREEBSD) */
 464
 465 #ifdef LINUX
 466 int
 467 sys_mq_open(struct tcb *tcp)
 468 {
 469         if (entering(tcp)) {
 470                 printpath(tcp, tcp->u_arg[0]);
 471                 tprints(", ");
 472                 /* flags */
 473                 tprint_open_modes(tcp->u_arg[1]);
 474                 if (tcp->u_arg[1] & O_CREAT) {
 475 # ifndef HAVE_MQUEUE_H
 476                         tprintf(", %lx", tcp->u_arg[2]);
 477 # else
 478                         struct mq_attr attr;
 479                         /* mode */
 480                         tprintf(", %#lo, ", tcp->u_arg[2]);
 481                         if (umove(tcp, tcp->u_arg[3], &attr) < 0)
 482                                 tprints("{ ??? }");
 483                         else
 484                                 tprintf("{mq_maxmsg=%ld, mq_msgsize=%ld}",
 485                                         attr.mq_maxmsg, attr.mq_msgsize);
 486 # endif
 487                 }
 488         }
 489         return 0;
 490 }
 491
 492 int
 493 sys_mq_timedsend(struct tcb *tcp)
 494 {
 495         if (entering(tcp)) {
 496                 tprintf("%ld, ", tcp->u_arg[0]);
 497                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 498                 tprintf(", %lu, %ld, ", tcp->u_arg[2], tcp->u_arg[3]);
 499                 printtv(tcp, tcp->u_arg[4]);
 500         }
 501         return 0;
 502 }
 503
 504 int
 505 sys_mq_timedreceive(struct tcb *tcp)
 506 {
 507         if (entering(tcp))
 508                 tprintf("%ld, ", tcp->u_arg[0]);
 509         else {
 510                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 511                 tprintf(", %lu, %ld, ", tcp->u_arg[2], tcp->u_arg[3]);
 512                 printtv(tcp, tcp->u_arg[4]);
 513         }
 514         return 0;
 515 }
 516
 517 int
 518 sys_mq_notify(struct tcb *tcp)
 519 {
 520         if (entering(tcp)) {
 521                 tprintf("%ld, ", tcp->u_arg[0]);
 522                 printsigevent(tcp, tcp->u_arg[1]);
 523         }
 524         return 0;
 525 }
 526
 527 static void
 528 printmqattr(struct tcb *tcp, long addr)
 529 {
 530         if (addr == 0)
 531                 tprints("NULL");
 532         else {
 533 # ifndef HAVE_MQUEUE_H
 534                 tprintf("%#lx", addr);
 535 # else
 536                 struct mq_attr attr;
 537                 if (umove(tcp, addr, &attr) < 0) {
 538                         tprints("{...}");
 539                         return;
 540                 }
 541                 tprints("{mq_flags=");
 542                 tprint_open_modes(attr.mq_flags);
 543                 tprintf(", mq_maxmsg=%ld, mq_msgsize=%ld, mq_curmsg=%ld}",
 544                         attr.mq_maxmsg, attr.mq_msgsize, attr.mq_curmsgs);
 545 # endif
 546         }
 547 }
 548
 549 int
 550 sys_mq_getsetattr(struct tcb *tcp)
 551 {
 552         if (entering(tcp)) {
 553                 tprintf("%ld, ", tcp->u_arg[0]);
 554                 printmqattr(tcp, tcp->u_arg[1]);
 555                 tprints(", ");
 556         } else
 557                 printmqattr(tcp, tcp->u_arg[2]);
 558         return 0;
 559 }
 560 #endif