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
  31 #include "defs.h"
  32 #ifdef HAVE_MQUEUE_H
  33 # include <mqueue.h>
  34 #endif
  35 #include <fcntl.h>
  36 #include <sys/ipc.h>
  37 #include <sys/sem.h>
  38 #include <sys/msg.h>
  39 #include <sys/shm.h>
  40
  41 #ifndef MSG_STAT
  42 #define MSG_STAT 11
  43 #endif
  44 #ifndef MSG_INFO
  45 #define MSG_INFO 12
  46 #endif
  47 #ifndef SHM_STAT
  48 #define SHM_STAT 13
  49 #endif
  50 #ifndef SHM_INFO
  51 #define SHM_INFO 14
  52 #endif
  53 #ifndef SEM_STAT
  54 #define SEM_STAT 18
  55 #endif
  56 #ifndef SEM_INFO
  57 #define SEM_INFO 19
  58 #endif
  59
  60 #if !defined IPC_64
  61 # define IPC_64 0x100
  62 #endif
  63
  64 extern void printsigevent(struct tcb *tcp, long arg);
  65
  66 #include "xlat/msgctl_flags.h"
  67 #include "xlat/semctl_flags.h"
  68 #include "xlat/shmctl_flags.h"
  69 #include "xlat/resource_flags.h"
  70 #include "xlat/shm_resource_flags.h"
  71 #include "xlat/shm_flags.h"
  72 #include "xlat/ipc_msg_flags.h"
  73 #include "xlat/semop_flags.h"
  74
  75 int sys_msgget(struct tcb *tcp)
  76 {
  77         if (entering(tcp)) {
  78                 if (tcp->u_arg[0])
  79                         tprintf("%#lx, ", tcp->u_arg[0]);
  80                 else
  81                         tprints("IPC_PRIVATE, ");
  82                 if (printflags(resource_flags, tcp->u_arg[1] & ~0777, NULL) != 0)
  83                         tprints("|");
  84                 tprintf("%#lo", tcp->u_arg[1] & 0777);
  85         }
  86         return 0;
  87 }
  88
  89 #ifdef IPC_64
  90 # define PRINTCTL(flagset, arg, dflt) \
  91         if ((arg) & IPC_64) tprints("IPC_64|"); \
  92         printxval((flagset), (arg) &~ IPC_64, dflt)
  93 #else
  94 # define PRINTCTL printxval
  95 #endif
  96
  97 static int
  98 indirect_ipccall(struct tcb *tcp)
  99 {
 100         return tcp->s_ent->sys_flags & TRACE_INDIRECT_SUBCALL;
 101 }
 102
 103 int sys_msgctl(struct tcb *tcp)
 104 {
 105         if (entering(tcp)) {
 106                 tprintf("%lu, ", tcp->u_arg[0]);
 107                 PRINTCTL(msgctl_flags, tcp->u_arg[1], "MSG_???");
 108                 tprintf(", %#lx", tcp->u_arg[indirect_ipccall(tcp) ? 3 : 2]);
 109         }
 110         return 0;
 111 }
 112
 113 static void
 114 tprint_msgsnd(struct tcb *tcp, long addr, unsigned long count,
 115               unsigned long flags)
 116 {
 117         long mtype;
 118
 119         if (umove(tcp, addr, &mtype) < 0) {
 120                 tprintf("%#lx", addr);
 121         } else {
 122                 tprintf("{%lu, ", mtype);
 123                 printstr(tcp, addr + sizeof(mtype), count);
 124                 tprints("}");
 125         }
 126         tprintf(", %lu, ", count);
 127         printflags(ipc_msg_flags, flags, "MSG_???");
 128 }
 129
 130 int sys_msgsnd(struct tcb *tcp)
 131 {
 132         if (entering(tcp)) {
 133                 tprintf("%d, ", (int) tcp->u_arg[0]);
 134                 if (indirect_ipccall(tcp)) {
 135                         tprint_msgsnd(tcp, tcp->u_arg[3], tcp->u_arg[1],
 136                                       tcp->u_arg[2]);
 137                 } else {
 138                         tprint_msgsnd(tcp, tcp->u_arg[1], tcp->u_arg[2],
 139                                       tcp->u_arg[3]);
 140                 }
 141         }
 142         return 0;
 143 }
 144
 145 static void
 146 tprint_msgrcv(struct tcb *tcp, long addr, unsigned long count, long msgtyp)
 147 {
 148         long mtype;
 149
 150         if (syserror(tcp) || umove(tcp, addr, &mtype) < 0) {
 151                 tprintf("%#lx", addr);
 152         } else {
 153                 tprintf("{%lu, ", mtype);
 154                 printstr(tcp, addr + sizeof(mtype), count);
 155                 tprints("}");
 156         }
 157         tprintf(", %lu, %ld, ", count, msgtyp);
 158 }
 159
 160 int sys_msgrcv(struct tcb *tcp)
 161 {
 162         if (entering(tcp)) {
 163                 tprintf("%d, ", (int) tcp->u_arg[0]);
 164         } else {
 165                 if (indirect_ipccall(tcp)) {
 166                         struct ipc_wrapper {
 167                                 struct msgbuf *msgp;
 168                                 long msgtyp;
 169                         } tmp;
 170
 171                         if (umove(tcp, tcp->u_arg[3], &tmp) < 0) {
 172                                 tprintf("%#lx, %lu, ",
 173                                         tcp->u_arg[3], tcp->u_arg[1]);
 174                         } else {
 175                                 tprint_msgrcv(tcp, (long) tmp.msgp,
 176                                         tcp->u_arg[1], tmp.msgtyp);
 177                         }
 178                         printflags(ipc_msg_flags, tcp->u_arg[2], "MSG_???");
 179                 } else {
 180                         tprint_msgrcv(tcp, tcp->u_arg[1],
 181                                 tcp->u_arg[2], tcp->u_arg[3]);
 182                         printflags(ipc_msg_flags, tcp->u_arg[4], "MSG_???");
 183                 }
 184         }
 185         return 0;
 186 }
 187
 188 static void
 189 tprint_sembuf(struct tcb *tcp, long addr, unsigned long count)
 190 {
 191         unsigned long i, max_count;
 192
 193         if (abbrev(tcp))
 194                 max_count = (max_strlen < count) ? max_strlen : count;
 195         else
 196                 max_count = count;
 197
 198         if (!max_count) {
 199                 tprintf("%#lx, %lu", addr, count);
 200                 return;
 201         }
 202
 203         for (i = 0; i < max_count; ++i) {
 204                 struct sembuf sb;
 205                 if (i)
 206                         tprints(", ");
 207                 if (umove(tcp, addr + i * sizeof(struct sembuf), &sb) < 0) {
 208                         if (i) {
 209                                 tprints("{???}");
 210                                 break;
 211                         } else {
 212                                 tprintf("%#lx, %lu", addr, count);
 213                                 return;
 214                         }
 215                 } else {
 216                         if (!i)
 217                                 tprints("{");
 218                         tprintf("{%u, %d, ", sb.sem_num, sb.sem_op);
 219                         printflags(semop_flags, sb.sem_flg, "SEM_???");
 220                         tprints("}");
 221                 }
 222         }
 223
 224         if (i < max_count || max_count < count)
 225                 tprints(", ...");
 226
 227         tprintf("}, %lu", count);
 228 }
 229
 230 int sys_semop(struct tcb *tcp)
 231 {
 232         if (entering(tcp)) {
 233                 tprintf("%lu, ", tcp->u_arg[0]);
 234                 if (indirect_ipccall(tcp)) {
 235                         tprint_sembuf(tcp, tcp->u_arg[3], tcp->u_arg[1]);
 236                 } else {
 237                         tprint_sembuf(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 238                 }
 239         }
 240         return 0;
 241 }
 242
 243 int sys_semtimedop(struct tcb *tcp)
 244 {
 245         if (entering(tcp)) {
 246                 tprintf("%lu, ", tcp->u_arg[0]);
 247                 if (indirect_ipccall(tcp)) {
 248                         tprint_sembuf(tcp, tcp->u_arg[3], tcp->u_arg[1]);
 249                         tprints(", ");
 250 #if defined(S390) || defined(S390X)
 251                         printtv(tcp, tcp->u_arg[2]);
 252 #else
 253                         printtv(tcp, tcp->u_arg[4]);
 254 #endif
 255                 } else {
 256                         tprint_sembuf(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 257                         tprints(", ");
 258                         printtv(tcp, tcp->u_arg[3]);
 259                 }
 260         }
 261         return 0;
 262 }
 263
 264 int sys_semget(struct tcb *tcp)
 265 {
 266         if (entering(tcp)) {
 267                 if (tcp->u_arg[0])
 268                         tprintf("%#lx", tcp->u_arg[0]);
 269                 else
 270                         tprints("IPC_PRIVATE");
 271                 tprintf(", %lu, ", tcp->u_arg[1]);
 272                 if (printflags(resource_flags, tcp->u_arg[2] & ~0777, NULL) != 0)
 273                         tprints("|");
 274                 tprintf("%#lo", tcp->u_arg[2] & 0777);
 275         }
 276         return 0;
 277 }
 278
 279 int sys_semctl(struct tcb *tcp)
 280 {
 281         if (entering(tcp)) {
 282                 tprintf("%lu, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
 283                 PRINTCTL(semctl_flags, tcp->u_arg[2], "SEM_???");
 284                 tprintf(", %#lx", tcp->u_arg[3]);
 285         }
 286         return 0;
 287 }
 288
 289 int sys_shmget(struct tcb *tcp)
 290 {
 291         if (entering(tcp)) {
 292                 if (tcp->u_arg[0])
 293                         tprintf("%#lx", tcp->u_arg[0]);
 294                 else
 295                         tprints("IPC_PRIVATE");
 296                 tprintf(", %lu, ", tcp->u_arg[1]);
 297                 if (printflags(shm_resource_flags, tcp->u_arg[2] & ~0777, NULL) != 0)
 298                         tprints("|");
 299                 tprintf("%#lo", tcp->u_arg[2] & 0777);
 300         }
 301         return 0;
 302 }
 303
 304 int sys_shmctl(struct tcb *tcp)
 305 {
 306         if (entering(tcp)) {
 307                 tprintf("%lu, ", tcp->u_arg[0]);
 308                 PRINTCTL(shmctl_flags, tcp->u_arg[1], "SHM_???");
 309                 if (indirect_ipccall(tcp)) {
 310                         tprintf(", %#lx", tcp->u_arg[3]);
 311                 } else {
 312                         tprintf(", %#lx", tcp->u_arg[2]);
 313                 }
 314         }
 315         return 0;
 316 }
 317
 318 int sys_shmat(struct tcb *tcp)
 319 {
 320         if (exiting(tcp)) {
 321                 tprintf("%lu", tcp->u_arg[0]);
 322                 if (indirect_ipccall(tcp)) {
 323                         tprintf(", %#lx, ", tcp->u_arg[3]);
 324                         printflags(shm_flags, tcp->u_arg[1], "SHM_???");
 325                 } else {
 326                         tprintf(", %#lx, ", tcp->u_arg[1]);
 327                         printflags(shm_flags, tcp->u_arg[2], "SHM_???");
 328                 }
 329                 if (syserror(tcp))
 330                         return 0;
 331                 if (indirect_ipccall(tcp)) {
 332                         unsigned long raddr;
 333                         if (umove(tcp, tcp->u_arg[2], &raddr) < 0)
 334                                 return RVAL_NONE;
 335                         tcp->u_rval = raddr;
 336                 }
 337                 return RVAL_HEX;
 338         }
 339         return 0;
 340 }
 341
 342 int sys_shmdt(struct tcb *tcp)
 343 {
 344         if (entering(tcp)) {
 345                 if (indirect_ipccall(tcp)) {
 346                         tprintf("%#lx", tcp->u_arg[3]);
 347                 } else {
 348                         tprintf("%#lx", tcp->u_arg[0]);
 349                 }
 350         }
 351         return 0;
 352 }
 353
 354 int
 355 sys_mq_open(struct tcb *tcp)
 356 {
 357         if (entering(tcp)) {
 358                 printpath(tcp, tcp->u_arg[0]);
 359                 tprints(", ");
 360                 /* flags */
 361                 tprint_open_modes(tcp->u_arg[1]);
 362                 if (tcp->u_arg[1] & O_CREAT) {
 363 # ifndef HAVE_MQUEUE_H
 364                         tprintf(", %lx", tcp->u_arg[2]);
 365 # else
 366                         struct mq_attr attr;
 367                         /* mode */
 368                         tprintf(", %#lo, ", tcp->u_arg[2]);
 369                         if (umove(tcp, tcp->u_arg[3], &attr) < 0)
 370                                 tprints("{???}");
 371                         else
 372                                 tprintf("{mq_maxmsg=%ld, mq_msgsize=%ld}",
 373                                         (long) attr.mq_maxmsg,
 374                                         (long) attr.mq_msgsize);
 375 # endif
 376                 }
 377         }
 378         return 0;
 379 }
 380
 381 int
 382 sys_mq_timedsend(struct tcb *tcp)
 383 {
 384         if (entering(tcp)) {
 385                 tprintf("%ld, ", tcp->u_arg[0]);
 386                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 387                 tprintf(", %lu, %ld, ", tcp->u_arg[2], tcp->u_arg[3]);
 388                 printtv(tcp, tcp->u_arg[4]);
 389         }
 390         return 0;
 391 }
 392
 393 int
 394 sys_mq_timedreceive(struct tcb *tcp)
 395 {
 396         if (entering(tcp))
 397                 tprintf("%ld, ", tcp->u_arg[0]);
 398         else {
 399                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 400                 tprintf(", %lu, %ld, ", tcp->u_arg[2], tcp->u_arg[3]);
 401                 printtv(tcp, tcp->u_arg[4]);
 402         }
 403         return 0;
 404 }
 405
 406 int
 407 sys_mq_notify(struct tcb *tcp)
 408 {
 409         if (entering(tcp)) {
 410                 tprintf("%ld, ", tcp->u_arg[0]);
 411                 printsigevent(tcp, tcp->u_arg[1]);
 412         }
 413         return 0;
 414 }
 415
 416 static void
 417 printmqattr(struct tcb *tcp, long addr)
 418 {
 419         if (addr == 0)
 420                 tprints("NULL");
 421         else {
 422 # ifndef HAVE_MQUEUE_H
 423                 tprintf("%#lx", addr);
 424 # else
 425                 struct mq_attr attr;
 426                 if (umove(tcp, addr, &attr) < 0) {
 427                         tprints("{...}");
 428                         return;
 429                 }
 430                 tprints("{mq_flags=");
 431                 tprint_open_modes(attr.mq_flags);
 432                 tprintf(", mq_maxmsg=%ld, mq_msgsize=%ld, mq_curmsg=%ld}",
 433                         (long) attr.mq_maxmsg, (long) attr.mq_msgsize,
 434                         (long) attr.mq_curmsgs);
 435 # endif
 436         }
 437 }
 438
 439 int
 440 sys_mq_getsetattr(struct tcb *tcp)
 441 {
 442         if (entering(tcp)) {
 443                 tprintf("%ld, ", tcp->u_arg[0]);
 444                 printmqattr(tcp, tcp->u_arg[1]);
 445                 tprints(", ");
 446         } else
 447                 printmqattr(tcp, tcp->u_arg[2]);
 448         return 0;
 449 }
 450
 451 int
 452 sys_ipc(struct tcb *tcp)
 453 {
 454         return printargs(tcp);
 455 }