sys-utils/ipcutils.c

   1 #include <inttypes.h>
   2
   3 #include "c.h"
   4 #include "nls.h"
   5 #include "xalloc.h"
   6 #include "path.h"
   7 #include "pathnames.h"
   8 #include "ipcutils.h"
   9 #include "strutils.h"
  10
  11 #ifndef SEMVMX
  12 # define SEMVMX  32767  /* <= 32767 semaphore maximum value */
  13 #endif
  14 #ifndef SHMMIN
  15 # define SHMMIN 1       /* min shared segment size in bytes */
  16 #endif
  17
  18
  19 int ipc_msg_get_limits(struct ipc_limits *lim)
  20 {
  21         memset(lim, 0, sizeof(*lim));
  22
  23         if (access(_PATH_PROC_IPC_MSGMNI, F_OK) == 0 &&
  24             access(_PATH_PROC_IPC_MSGMNB, F_OK) == 0 &&
  25             access(_PATH_PROC_IPC_MSGMAX, F_OK) == 0) {
  26
  27                 if (ul_path_read_s32(NULL, &lim->msgmni, _PATH_PROC_IPC_MSGMNI) != 0)
  28                         return 1;
  29                 if (ul_path_read_s32(NULL, &lim->msgmnb, _PATH_PROC_IPC_MSGMNB) != 0)
  30                         return 1;
  31                 if (ul_path_read_u64(NULL, &lim->msgmax, _PATH_PROC_IPC_MSGMAX) != 0)
  32                         return 1;
  33         } else {
  34                 struct msginfo msginfo;
  35
  36                 if (msgctl(0, IPC_INFO, (struct msqid_ds *) &msginfo) < 0)
  37                         return 1;
  38                 lim->msgmni = msginfo.msgmni;
  39                 lim->msgmnb = msginfo.msgmnb;
  40                 lim->msgmax = msginfo.msgmax;
  41         }
  42
  43         return 0;
  44 }
  45
  46 int ipc_sem_get_limits(struct ipc_limits *lim)
  47 {
  48         FILE *f;
  49         int rc = 0;
  50
  51         lim->semvmx = SEMVMX;
  52
  53         f = fopen(_PATH_PROC_IPC_SEM, "r");
  54         if (f) {
  55                 rc = fscanf(f, "%d\t%d\t%d\t%d",
  56                        &lim->semmsl, &lim->semmns, &lim->semopm, &lim->semmni);
  57                 fclose(f);
  58         }
  59
  60         if (rc != 4) {
  61                 struct seminfo seminfo = { .semmni = 0 };
  62                 union semun arg = { .array = (ushort *) &seminfo };
  63
  64                 if (semctl(0, 0, IPC_INFO, arg) < 0)
  65                         return 1;
  66                 lim->semmni = seminfo.semmni;
  67                 lim->semmsl = seminfo.semmsl;
  68                 lim->semmns = seminfo.semmns;
  69                 lim->semopm = seminfo.semopm;
  70         }
  71
  72         return 0;
  73 }
  74
  75 int ipc_shm_get_limits(struct ipc_limits *lim)
  76 {
  77         lim->shmmin = SHMMIN;
  78
  79         if (access(_PATH_PROC_IPC_SHMALL, F_OK) == 0 &&
  80             access(_PATH_PROC_IPC_SHMMAX, F_OK) == 0 &&
  81             access(_PATH_PROC_IPC_SHMMNI, F_OK) == 0) {
  82
  83                 ul_path_read_u64(NULL, &lim->shmall, _PATH_PROC_IPC_SHMALL);
  84                 ul_path_read_u64(NULL, &lim->shmmax, _PATH_PROC_IPC_SHMMAX);
  85                 ul_path_read_u64(NULL, &lim->shmmni, _PATH_PROC_IPC_SHMMNI);
  86
  87         } else {
  88                 struct shminfo *shminfo;
  89                 struct shmid_ds shmbuf;
  90
  91                 if (shmctl(0, IPC_INFO, &shmbuf) < 0)
  92                         return 1;
  93                 shminfo = (struct shminfo *) &shmbuf;
  94                 lim->shmmni = shminfo->shmmni;
  95                 lim->shmall = shminfo->shmall;
  96                 lim->shmmax = shminfo->shmmax;
  97         }
  98
  99         return 0;
 100 }
 101
 102 int ipc_shm_get_info(int id, struct shm_data **shmds)
 103 {
 104         FILE *f;
 105         int i = 0, maxid, j;
 106         char buf[BUFSIZ];
 107         struct shm_data *p;
 108         struct shmid_ds dummy;
 109
 110         p = *shmds = xcalloc(1, sizeof(struct shm_data));
 111         p->next = NULL;
 112
 113         f = fopen(_PATH_PROC_SYSV_SHM, "r");
 114         if (!f)
 115                 goto shm_fallback;
 116
 117         while (fgetc(f) != '\n');               /* skip header */
 118
 119         while (fgets(buf, sizeof(buf), f) != NULL) {
 120                 /* scan for the first 14-16 columns (e.g. Linux 2.6.32 has 14) */
 121                 p->shm_rss = 0xdead;
 122                 p->shm_swp = 0xdead;
 123                 if (sscanf(buf,
 124                           "%d %d  %o %"SCNu64 " %u %u  "
 125                           "%"SCNu64 " %u %u %u %u %"SCNi64 " %"SCNi64 " %"SCNi64
 126                           " %"SCNu64 " %"SCNu64 "\n",
 127                            &p->shm_perm.key,
 128                            &p->shm_perm.id,
 129                            &p->shm_perm.mode,
 130                            &p->shm_segsz,
 131                            &p->shm_cprid,
 132                            &p->shm_lprid,
 133                            &p->shm_nattch,
 134                            &p->shm_perm.uid,
 135                            &p->shm_perm.gid,
 136                            &p->shm_perm.cuid,
 137                            &p->shm_perm.cgid,
 138                            &p->shm_atim,
 139                            &p->shm_dtim,
 140                            &p->shm_ctim,
 141                            &p->shm_rss,
 142                            &p->shm_swp) < 14)
 143                         continue; /* invalid line, skipped */
 144
 145                 if (id > -1) {
 146                         /* ID specified */
 147                         if (id == p->shm_perm.id) {
 148                                 i = 1;
 149                                 break;
 150                         }
 151                         continue;
 152                 }
 153
 154                 p->next = xcalloc(1, sizeof(struct shm_data));
 155                 p = p->next;
 156                 p->next = NULL;
 157                 i++;
 158         }
 159
 160         if (i == 0)
 161                 free(*shmds);
 162         fclose(f);
 163         return i;
 164
 165         /* Fallback; /proc or /sys file(s) missing. */
 166 shm_fallback:
 167         maxid = shmctl(0, SHM_INFO, &dummy);
 168
 169         for (j = 0; j <= maxid; j++) {
 170                 int shmid;
 171                 struct shmid_ds shmseg;
 172                 struct ipc_perm *ipcp = &shmseg.shm_perm;
 173
 174                 shmid = shmctl(j, SHM_STAT, &shmseg);
 175                 if (shmid < 0 || (id > -1 && shmid != id)) {
 176                         continue;
 177                 }
 178
 179                 i++;
 180                 p->shm_perm.key = ipcp->KEY;
 181                 p->shm_perm.id = shmid;
 182                 p->shm_perm.mode = ipcp->mode;
 183                 p->shm_segsz = shmseg.shm_segsz;
 184                 p->shm_cprid = shmseg.shm_cpid;
 185                 p->shm_lprid = shmseg.shm_lpid;
 186                 p->shm_nattch = shmseg.shm_nattch;
 187                 p->shm_perm.uid = ipcp->uid;
 188                 p->shm_perm.gid = ipcp->gid;
 189                 p->shm_perm.cuid = ipcp->cuid;
 190                 p->shm_perm.cgid = ipcp->cuid;
 191                 p->shm_atim = shmseg.shm_atime;
 192                 p->shm_dtim = shmseg.shm_dtime;
 193                 p->shm_ctim = shmseg.shm_ctime;
 194                 p->shm_rss = 0xdead;
 195                 p->shm_swp = 0xdead;
 196
 197                 if (id < 0) {
 198                         p->next = xcalloc(1, sizeof(struct shm_data));
 199                         p = p->next;
 200                         p->next = NULL;
 201                 } else
 202                         break;
 203         }
 204
 205         if (i == 0)
 206                 free(*shmds);
 207         return i;
 208 }
 209
 210 void ipc_shm_free_info(struct shm_data *shmds)
 211 {
 212         while (shmds) {
 213                 struct shm_data *next = shmds->next;
 214                 free(shmds);
 215                 shmds = next;
 216         }
 217 }
 218
 219 static void get_sem_elements(struct sem_data *p)
 220 {
 221         size_t i;
 222
 223         if (!p || !p->sem_nsems || p->sem_nsems > SIZE_MAX || p->sem_perm.id < 0)
 224                 return;
 225
 226         p->elements = xcalloc(p->sem_nsems, sizeof(struct sem_elem));
 227
 228         for (i = 0; i < p->sem_nsems; i++) {
 229                 struct sem_elem *e = &p->elements[i];
 230                 union semun arg = { .val = 0 };
 231
 232                 e->semval = semctl(p->sem_perm.id, i, GETVAL, arg);
 233                 if (e->semval < 0)
 234                         err(EXIT_FAILURE, _("%s failed"), "semctl(GETVAL)");
 235
 236                 e->ncount = semctl(p->sem_perm.id, i, GETNCNT, arg);
 237                 if (e->ncount < 0)
 238                         err(EXIT_FAILURE, _("%s failed"), "semctl(GETNCNT)");
 239
 240                 e->zcount = semctl(p->sem_perm.id, i, GETZCNT, arg);
 241                 if (e->zcount < 0)
 242                         err(EXIT_FAILURE, _("%s failed"), "semctl(GETZCNT)");
 243
 244                 e->pid = semctl(p->sem_perm.id, i, GETPID, arg);
 245                 if (e->pid < 0)
 246                         err(EXIT_FAILURE, _("%s failed"), "semctl(GETPID)");
 247         }
 248 }
 249
 250 int ipc_sem_get_info(int id, struct sem_data **semds)
 251 {
 252         FILE *f;
 253         int i = 0, maxid, j;
 254         struct sem_data *p;
 255         struct seminfo dummy;
 256         union semun arg;
 257
 258         p = *semds = xcalloc(1, sizeof(struct sem_data));
 259         p->next = NULL;
 260
 261         f = fopen(_PATH_PROC_SYSV_SEM, "r");
 262         if (!f)
 263                 goto sem_fallback;
 264
 265         while (fgetc(f) != '\n') ;      /* skip header */
 266
 267         while (feof(f) == 0) {
 268                 if (fscanf(f,
 269                            "%d %d  %o %" SCNu64 " %u %u %u %u %"
 270                             SCNi64 " %" SCNi64 "\n",
 271                            &p->sem_perm.key,
 272                            &p->sem_perm.id,
 273                            &p->sem_perm.mode,
 274                            &p->sem_nsems,
 275                            &p->sem_perm.uid,
 276                            &p->sem_perm.gid,
 277                            &p->sem_perm.cuid,
 278                            &p->sem_perm.cgid,
 279                            &p->sem_otime,
 280                            &p->sem_ctime) != 10)
 281                         continue;
 282
 283                 if (id > -1) {
 284                         /* ID specified */
 285                         if (id == p->sem_perm.id) {
 286                                 get_sem_elements(p);
 287                                 i = 1;
 288                                 break;
 289                         }
 290                         continue;
 291                 }
 292
 293                 p->next = xcalloc(1, sizeof(struct sem_data));
 294                 p = p->next;
 295                 p->next = NULL;
 296                 i++;
 297         }
 298
 299         if (i == 0)
 300                 free(*semds);
 301         fclose(f);
 302         return i;
 303
 304         /* Fallback; /proc or /sys file(s) missing. */
 305 sem_fallback:
 306         arg.array = (ushort *) (void *)&dummy;
 307         maxid = semctl(0, 0, SEM_INFO, arg);
 308
 309         for (j = 0; j <= maxid; j++) {
 310                 int semid;
 311                 struct semid_ds semseg;
 312                 struct ipc_perm *ipcp = &semseg.sem_perm;
 313                 arg.buf = (struct semid_ds *)&semseg;
 314
 315                 semid = semctl(j, 0, SEM_STAT, arg);
 316                 if (semid < 0 || (id > -1 && semid != id)) {
 317                         continue;
 318                 }
 319
 320                 i++;
 321                 p->sem_perm.key = ipcp->KEY;
 322                 p->sem_perm.id = semid;
 323                 p->sem_perm.mode = ipcp->mode;
 324                 p->sem_nsems = semseg.sem_nsems;
 325                 p->sem_perm.uid = ipcp->uid;
 326                 p->sem_perm.gid = ipcp->gid;
 327                 p->sem_perm.cuid = ipcp->cuid;
 328                 p->sem_perm.cgid = ipcp->cuid;
 329                 p->sem_otime = semseg.sem_otime;
 330                 p->sem_ctime = semseg.sem_ctime;
 331
 332                 if (id < 0) {
 333                         p->next = xcalloc(1, sizeof(struct sem_data));
 334                         p = p->next;
 335                         p->next = NULL;
 336                         i++;
 337                 } else {
 338                         get_sem_elements(p);
 339                         break;
 340                 }
 341         }
 342
 343         if (i == 0)
 344                 free(*semds);
 345         return i;
 346 }
 347
 348 void ipc_sem_free_info(struct sem_data *semds)
 349 {
 350         while (semds) {
 351                 struct sem_data *next = semds->next;
 352                 free(semds->elements);
 353                 free(semds);
 354                 semds = next;
 355         }
 356 }
 357
 358 int ipc_msg_get_info(int id, struct msg_data **msgds)
 359 {
 360         FILE *f;
 361         int i = 0, maxid, j;
 362         struct msg_data *p;
 363         struct msqid_ds dummy;
 364         struct msqid_ds msgseg;
 365
 366         p = *msgds = xcalloc(1, sizeof(struct msg_data));
 367         p->next = NULL;
 368
 369         f = fopen(_PATH_PROC_SYSV_MSG, "r");
 370         if (!f)
 371                 goto msg_fallback;
 372
 373         while (fgetc(f) != '\n') ;      /* skip header */
 374
 375         while (feof(f) == 0) {
 376                 if (fscanf(f,
 377                            "%d %d  %o  %" SCNu64 " %" SCNu64
 378                            " %u %u %u %u %u %u %" SCNi64 " %" SCNi64 " %" SCNi64 "\n",
 379                            &p->msg_perm.key,
 380                            &p->msg_perm.id,
 381                            &p->msg_perm.mode,
 382                            &p->q_cbytes,
 383                            &p->q_qnum,
 384                            &p->q_lspid,
 385                            &p->q_lrpid,
 386                            &p->msg_perm.uid,
 387                            &p->msg_perm.gid,
 388                            &p->msg_perm.cuid,
 389                            &p->msg_perm.cgid,
 390                            &p->q_stime,
 391                            &p->q_rtime,
 392                            &p->q_ctime) != 14)
 393                         continue;
 394
 395                 if (id > -1) {
 396                         /* ID specified */
 397                         if (id == p->msg_perm.id) {
 398                                 if (msgctl(id, IPC_STAT, &msgseg) != -1)
 399                                         p->q_qbytes = msgseg.msg_qbytes;
 400                                 i = 1;
 401                                 break;
 402                         }
 403                         continue;
 404                 }
 405
 406                 p->next = xcalloc(1, sizeof(struct msg_data));
 407                 p = p->next;
 408                 p->next = NULL;
 409                 i++;
 410         }
 411
 412         if (i == 0)
 413                 free(*msgds);
 414         fclose(f);
 415         return i;
 416
 417         /* Fallback; /proc or /sys file(s) missing. */
 418 msg_fallback:
 419         maxid = msgctl(0, MSG_INFO, &dummy);
 420
 421         for (j = 0; j <= maxid; j++) {
 422                 int msgid;
 423                 struct ipc_perm *ipcp = &msgseg.msg_perm;
 424
 425                 msgid = msgctl(j, MSG_STAT, &msgseg);
 426                 if (msgid < 0 || (id > -1 && msgid != id)) {
 427                         continue;
 428                 }
 429
 430                 i++;
 431                 p->msg_perm.key = ipcp->KEY;
 432                 p->msg_perm.id = msgid;
 433                 p->msg_perm.mode = ipcp->mode;
 434                 p->q_cbytes = msgseg.msg_cbytes;
 435                 p->q_qnum = msgseg.msg_qnum;
 436                 p->q_lspid = msgseg.msg_lspid;
 437                 p->q_lrpid = msgseg.msg_lrpid;
 438                 p->msg_perm.uid = ipcp->uid;
 439                 p->msg_perm.gid = ipcp->gid;
 440                 p->msg_perm.cuid = ipcp->cuid;
 441                 p->msg_perm.cgid = ipcp->cgid;
 442                 p->q_stime = msgseg.msg_stime;
 443                 p->q_rtime = msgseg.msg_rtime;
 444                 p->q_ctime = msgseg.msg_ctime;
 445                 p->q_qbytes = msgseg.msg_qbytes;
 446
 447                 if (id < 0) {
 448                         p->next = xcalloc(1, sizeof(struct msg_data));
 449                         p = p->next;
 450                         p->next = NULL;
 451                 } else
 452                         break;
 453         }
 454
 455         if (i == 0)
 456                 free(*msgds);
 457         return i;
 458 }
 459
 460 void ipc_msg_free_info(struct msg_data *msgds)
 461 {
 462         while (msgds) {
 463                 struct msg_data *next = msgds->next;
 464                 free(msgds);
 465                 msgds = next;
 466         }
 467 }
 468
 469 void ipc_print_perms(FILE *f, struct ipc_stat *is)
 470 {
 471         struct passwd *pw;
 472         struct group *gr;
 473
 474         fprintf(f, "%-10d %-10o", is->id, is->mode & 0777);
 475
 476         if ((pw = getpwuid(is->cuid)))
 477                 fprintf(f, " %-10s", pw->pw_name);
 478         else
 479                 fprintf(f, " %-10u", is->cuid);
 480
 481         if ((gr = getgrgid(is->cgid)))
 482                 fprintf(f, " %-10s", gr->gr_name);
 483         else
 484                 fprintf(f, " %-10u", is->cgid);
 485
 486         if ((pw = getpwuid(is->uid)))
 487                 fprintf(f, " %-10s", pw->pw_name);
 488         else
 489                 fprintf(f, " %-10u", is->uid);
 490
 491         if ((gr = getgrgid(is->gid)))
 492                 fprintf(f, " %-10s\n", gr->gr_name);
 493         else
 494                 fprintf(f, " %-10u\n", is->gid);
 495 }
 496
 497 void ipc_print_size(int unit, char *msg, uint64_t size, const char *end,
 498                     int width)
 499 {
 500         char format[32];
 501
 502         if (!msg)
 503                 /* NULL */ ;
 504         else if (msg[strlen(msg) - 1] == '=')
 505                 printf("%s", msg);
 506         else if (unit == IPC_UNIT_BYTES)
 507                 printf(_("%s (bytes) = "), msg);
 508         else if (unit == IPC_UNIT_KB)
 509                 printf(_("%s (kbytes) = "), msg);
 510         else
 511                 printf("%s = ", msg);
 512
 513         switch (unit) {
 514         case IPC_UNIT_DEFAULT:
 515         case IPC_UNIT_BYTES:
 516                 snprintf(format, sizeof(format), "%%%dju", width);
 517                 printf(format, size);
 518                 break;
 519         case IPC_UNIT_KB:
 520                 snprintf(format, sizeof(format), "%%%dju", width);
 521                 printf(format, size / 1024);
 522                 break;
 523         case IPC_UNIT_HUMAN:
 524         {
 525                 char *tmp;
 526                 snprintf(format, sizeof(format), "%%%ds", width);
 527                 printf(format, (tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, size)));
 528                 free(tmp);
 529                 break;
 530         }
 531         default:
 532                 /* impossible occurred */
 533                 abort();
 534         }
 535
 536         if (end)
 537                 printf("%s", end);
 538 }