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

   1 /*
   2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
   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  * Copyright (c) 2005-2016 Dmitry V. Levin <ldv@altlinux.org>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. The name of the author may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "defs.h"
  33
  34 #define SUBCMDMASK  0x00ff
  35 #define SUBCMDSHIFT 8
  36 #define QCMD_CMD(cmd)   ((uint32_t)(cmd) >> SUBCMDSHIFT)
  37 #define QCMD_TYPE(cmd)  ((uint32_t)(cmd) & SUBCMDMASK)
  38
  39 #define OLD_CMD(cmd)    ((uint32_t)(cmd) << SUBCMDSHIFT)
  40 #define NEW_CMD(cmd)    ((uint32_t)(cmd) | 0x800000)
  41 #define XQM_CMD(cmd)    ((uint32_t)(cmd) | ('X' << SUBCMDSHIFT))
  42
  43 #include "xlat/quotacmds.h"
  44 #include "xlat/quotatypes.h"
  45 #include "xlat/quota_formats.h"
  46 #include "xlat/xfs_quota_flags.h"
  47 #include "xlat/xfs_dqblk_flags.h"
  48 #include "xlat/if_dqblk_valid.h"
  49 #include "xlat/if_dqinfo_flags.h"
  50 #include "xlat/if_dqinfo_valid.h"
  51
  52 /*
  53  * We add attribute packed due to the fact that the structure is 8-byte aligned
  54  * on 64-bit systems and therefore has additional 4 bytes of padding, which
  55  * leads to problems when it is used on 32-bit tracee which does not have such
  56  * padding.
  57  */
  58 struct if_dqblk
  59 {
  60         uint64_t dqb_bhardlimit;
  61         uint64_t dqb_bsoftlimit;
  62         uint64_t dqb_curspace;
  63         uint64_t dqb_ihardlimit;
  64         uint64_t dqb_isoftlimit;
  65         uint64_t dqb_curinodes;
  66         uint64_t dqb_btime;
  67         uint64_t dqb_itime;
  68         uint32_t dqb_valid;
  69 } ATTRIBUTE_PACKED;
  70
  71 struct if_nextdqblk {
  72         uint64_t dqb_bhardlimit;
  73         uint64_t dqb_bsoftlimit;
  74         uint64_t dqb_curspace;
  75         uint64_t dqb_ihardlimit;
  76         uint64_t dqb_isoftlimit;
  77         uint64_t dqb_curinodes;
  78         uint64_t dqb_btime;
  79         uint64_t dqb_itime;
  80         uint32_t dqb_valid;
  81         uint32_t dqb_id;
  82 };
  83
  84 struct xfs_dqblk
  85 {
  86         int8_t  d_version;              /* version of this structure */
  87         int8_t  d_flags;                /* XFS_{USER,PROJ,GROUP}_QUOTA */
  88         uint16_t d_fieldmask;           /* field specifier */
  89         uint32_t d_id;                  /* user, project, or group ID */
  90         uint64_t d_blk_hardlimit;       /* absolute limit on disk blks */
  91         uint64_t d_blk_softlimit;       /* preferred limit on disk blks */
  92         uint64_t d_ino_hardlimit;       /* maximum # allocated inodes */
  93         uint64_t d_ino_softlimit;       /* preferred inode limit */
  94         uint64_t d_bcount;              /* # disk blocks owned by the user */
  95         uint64_t d_icount;              /* # inodes owned by the user */
  96         int32_t d_itimer;               /* zero if within inode limits */
  97         int32_t d_btimer;               /* similar to above; for disk blocks */
  98         uint16_t d_iwarns;              /* # warnings issued wrt num inodes */
  99         uint16_t d_bwarns;              /* # warnings issued wrt disk blocks */
 100         int32_t d_padding2;             /* padding2 - for future use */
 101         uint64_t d_rtb_hardlimit;       /* absolute limit on realtime blks */
 102         uint64_t d_rtb_softlimit;       /* preferred limit on RT disk blks */
 103         uint64_t d_rtbcount;            /* # realtime blocks owned */
 104         int32_t d_rtbtimer;             /* similar to above; for RT disk blks */
 105         uint16_t d_rtbwarns;            /* # warnings issued wrt RT disk blks */
 106         int16_t d_padding3;             /* padding3 - for future use */
 107         char    d_padding4[8];          /* yet more padding */
 108 };
 109
 110 struct if_dqinfo
 111 {
 112         uint64_t dqi_bgrace;
 113         uint64_t dqi_igrace;
 114         uint32_t dqi_flags;
 115         uint32_t dqi_valid;
 116 };
 117
 118 typedef struct fs_qfilestat
 119 {
 120         uint64_t qfs_ino;       /* inode number */
 121         uint64_t qfs_nblks;     /* number of BBs 512-byte-blks */
 122         uint32_t qfs_nextents;  /* number of extents */
 123 } fs_qfilestat_t;
 124
 125 struct xfs_dqstats
 126 {
 127         int8_t  qs_version;             /* version number for future changes */
 128         uint16_t qs_flags;              /* XFS_QUOTA_{U,P,G}DQ_{ACCT,ENFD} */
 129         int8_t  qs_pad;                 /* unused */
 130         fs_qfilestat_t qs_uquota;       /* user quota storage information */
 131         fs_qfilestat_t qs_gquota;       /* group quota storage information */
 132         uint32_t qs_incoredqs;          /* number of dquots incore */
 133         int32_t qs_btimelimit;          /* limit for blks timer */
 134         int32_t qs_itimelimit;          /* limit for inodes timer */
 135         int32_t qs_rtbtimelimit;        /* limit for rt blks timer */
 136         uint16_t qs_bwarnlimit;         /* limit for num warnings */
 137         uint16_t qs_iwarnlimit;         /* limit for num warnings */
 138 };
 139
 140 struct fs_qfilestatv {
 141         uint64_t qfs_ino, qfs_nblks;
 142         uint32_t qfs_nextents, qfs_pad;
 143 };
 144
 145 struct fs_quota_statv {
 146         int8_t qs_version;
 147         uint8_t qs_pad1;
 148         uint16_t qs_flags;
 149         uint32_t qs_incoredqs;
 150         struct fs_qfilestatv qs_uquota;
 151         struct fs_qfilestatv qs_gquota;
 152         struct fs_qfilestatv qs_pquota;
 153         int32_t qs_btimelimit;
 154         int32_t qs_itimelimit;
 155         int32_t qs_rtbtimelimit;
 156         uint16_t qs_bwarnlimit;
 157         uint16_t qs_iwarnlimit;
 158         uint64_t qs_pad2[8];
 159 };
 160
 161 #define PRINT_FIELD_D(prefix, where, field)     \
 162         tprintf("%s%s=%lld", (prefix), #field,  \
 163                 sign_extend_unsigned_to_ll((where).field))
 164
 165 #define PRINT_FIELD_U(prefix, where, field)     \
 166         tprintf("%s%s=%llu", (prefix), #field,  \
 167                 zero_extend_signed_to_ull((where).field))
 168
 169 #define PRINT_FIELD_X(prefix, where, field)     \
 170         tprintf("%s%s=%#llx", (prefix), #field, \
 171                 zero_extend_signed_to_ull((where).field))
 172
 173 static int
 174 decode_cmd_data(struct tcb *tcp, uint32_t id, uint32_t cmd, unsigned long data)
 175 {
 176         switch (cmd) {
 177         case Q_QUOTAOFF:
 178         case Q_SYNC:
 179         case Q_XQUOTASYNC:
 180                 break;
 181         case Q_QUOTAON:
 182                 tprints(", ");
 183                 printxval(quota_formats, id, "QFMT_VFS_???");
 184                 tprints(", ");
 185                 printpath(tcp, data);
 186                 break;
 187         case Q_GETQUOTA:
 188                 if (entering(tcp)) {
 189                         printuid(", ", id);
 190                         tprints(", ");
 191
 192                         return 0;
 193                 }
 194
 195                 /* Fall-through */
 196         case Q_SETQUOTA:
 197         {
 198                 struct if_dqblk dq;
 199
 200                 if (entering(tcp)) {
 201                         printuid(", ", id);
 202                         tprints(", ");
 203                 }
 204
 205                 if (umove_or_printaddr(tcp, data, &dq))
 206                         break;
 207                 PRINT_FIELD_U("{", dq, dqb_bhardlimit);
 208                 PRINT_FIELD_U(", ", dq, dqb_bsoftlimit);
 209                 PRINT_FIELD_U(", ", dq, dqb_curspace);
 210                 PRINT_FIELD_U(", ", dq, dqb_ihardlimit);
 211                 PRINT_FIELD_U(", ", dq, dqb_isoftlimit);
 212                 PRINT_FIELD_U(", ", dq, dqb_curinodes);
 213                 if (!abbrev(tcp)) {
 214                         PRINT_FIELD_U(", ", dq, dqb_btime);
 215                         PRINT_FIELD_U(", ", dq, dqb_itime);
 216                         tprints(", dqb_valid=");
 217                         printflags(if_dqblk_valid,
 218                                    dq.dqb_valid, "QIF_???");
 219                 } else {
 220                         tprints(", ...");
 221                 }
 222                 tprints("}");
 223                 break;
 224         }
 225         case Q_GETNEXTQUOTA:
 226         {
 227                 struct if_nextdqblk dq;
 228
 229                 if (entering(tcp)) {
 230                         printuid(", ", id);
 231                         tprints(", ");
 232
 233                         return 0;
 234                 }
 235
 236                 if (umove_or_printaddr(tcp, data, &dq))
 237                         break;
 238                 PRINT_FIELD_U("{", dq, dqb_bhardlimit);
 239                 PRINT_FIELD_U(", ", dq, dqb_bsoftlimit);
 240                 PRINT_FIELD_U(", ", dq, dqb_curspace);
 241                 PRINT_FIELD_U(", ", dq, dqb_ihardlimit);
 242                 PRINT_FIELD_U(", ", dq, dqb_isoftlimit);
 243                 PRINT_FIELD_U(", ", dq, dqb_curinodes);
 244                 if (!abbrev(tcp)) {
 245                         PRINT_FIELD_U(", ", dq, dqb_btime);
 246                         PRINT_FIELD_U(", ", dq, dqb_itime);
 247                         tprints(", dqb_valid=");
 248                         printflags(if_dqblk_valid,
 249                                    dq.dqb_valid, "QIF_???");
 250                         PRINT_FIELD_U(", ", dq, dqb_id);
 251                 } else {
 252                         PRINT_FIELD_U(", ", dq, dqb_id);
 253                         tprints(", ...");
 254                 }
 255                 tprints("}");
 256                 break;
 257         }
 258         case Q_XGETQUOTA:
 259         case Q_XGETNEXTQUOTA:
 260                 if (entering(tcp)) {
 261                         printuid(", ", id);
 262                         tprints(", ");
 263
 264                         return 0;
 265                 }
 266
 267                 /* Fall-through */
 268         case Q_XSETQLIM:
 269         {
 270                 struct xfs_dqblk dq;
 271
 272                 if (entering(tcp)) {
 273                         printuid(", ", id);
 274                         tprints(", ");
 275                 }
 276
 277                 if (umove_or_printaddr(tcp, data, &dq))
 278                         break;
 279                 PRINT_FIELD_D("{", dq, d_version);
 280                 tprints(", d_flags=");
 281                 printflags(xfs_dqblk_flags,
 282                            (uint8_t) dq.d_flags, "XFS_???_QUOTA");
 283                 PRINT_FIELD_X(", ", dq, d_fieldmask);
 284                 PRINT_FIELD_U(", ", dq, d_id);
 285                 PRINT_FIELD_U(", ", dq, d_blk_hardlimit);
 286                 PRINT_FIELD_U(", ", dq, d_blk_softlimit);
 287                 PRINT_FIELD_U(", ", dq, d_ino_hardlimit);
 288                 PRINT_FIELD_U(", ", dq, d_ino_softlimit);
 289                 PRINT_FIELD_U(", ", dq, d_bcount);
 290                 PRINT_FIELD_U(", ", dq, d_icount);
 291                 if (!abbrev(tcp)) {
 292                         PRINT_FIELD_D(", ", dq, d_itimer);
 293                         PRINT_FIELD_D(", ", dq, d_btimer);
 294                         PRINT_FIELD_U(", ", dq, d_iwarns);
 295                         PRINT_FIELD_U(", ", dq, d_bwarns);
 296                         PRINT_FIELD_U(", ", dq, d_rtb_hardlimit);
 297                         PRINT_FIELD_U(", ", dq, d_rtb_softlimit);
 298                         PRINT_FIELD_U(", ", dq, d_rtbcount);
 299                         PRINT_FIELD_D(", ", dq, d_rtbtimer);
 300                         PRINT_FIELD_U(", ", dq, d_rtbwarns);
 301                 } else {
 302                         tprints(", ...");
 303                 }
 304                 tprints("}");
 305                 break;
 306         }
 307         case Q_GETFMT:
 308         {
 309                 uint32_t fmt;
 310
 311                 if (entering(tcp)) {
 312                         tprints(", ");
 313
 314                         return 0;
 315                 }
 316
 317                 if (umove_or_printaddr(tcp, data, &fmt))
 318                         break;
 319                 tprints("[");
 320                 printxval(quota_formats, fmt, "QFMT_VFS_???");
 321                 tprints("]");
 322                 break;
 323         }
 324         case Q_GETINFO:
 325                 if (entering(tcp)) {
 326                         tprints(", ");
 327
 328                         return 0;
 329                 }
 330
 331                 /* Fall-through */
 332         case Q_SETINFO:
 333         {
 334                 struct if_dqinfo dq;
 335
 336                 if (entering(tcp))
 337                         tprints(", ");
 338
 339                 if (umove_or_printaddr(tcp, data, &dq))
 340                         break;
 341                 PRINT_FIELD_U("{", dq, dqi_bgrace);
 342                 PRINT_FIELD_U(", ", dq, dqi_igrace);
 343                 tprints(", dqi_flags=");
 344                 printflags(if_dqinfo_flags, dq.dqi_flags, "DQF_???");
 345                 tprints(", dqi_valid=");
 346                 printflags(if_dqinfo_valid, dq.dqi_valid, "IIF_???");
 347                 tprints("}");
 348                 break;
 349         }
 350         case Q_XGETQSTAT:
 351         {
 352                 struct xfs_dqstats dq;
 353
 354                 if (entering(tcp)) {
 355                         tprints(", ");
 356
 357                         return 0;
 358                 }
 359
 360                 if (umove_or_printaddr(tcp, data, &dq))
 361                         break;
 362                 PRINT_FIELD_D("{", dq, qs_version);
 363                 if (!abbrev(tcp)) {
 364                         tprints(", qs_flags=");
 365                         printflags(xfs_quota_flags,
 366                                    dq.qs_flags, "XFS_QUOTA_???");
 367                         PRINT_FIELD_U(", ", dq, qs_incoredqs);
 368                         PRINT_FIELD_U(", qs_uquota={", dq.qs_uquota, qfs_ino);
 369                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nblks);
 370                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nextents);
 371                         PRINT_FIELD_U("}, qs_gquota={", dq.qs_gquota, qfs_ino);
 372                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nblks);
 373                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nextents);
 374                         PRINT_FIELD_D("}, ", dq, qs_btimelimit);
 375                         PRINT_FIELD_D(", ", dq, qs_itimelimit);
 376                         PRINT_FIELD_D(", ", dq, qs_rtbtimelimit);
 377                         PRINT_FIELD_U(", ", dq, qs_bwarnlimit);
 378                         PRINT_FIELD_U(", ", dq, qs_iwarnlimit);
 379                 } else {
 380                         tprints(", ...");
 381                 }
 382                 tprints("}");
 383                 break;
 384         }
 385         case Q_XGETQSTATV:
 386         {
 387                 struct fs_quota_statv dq;
 388
 389                 if (entering(tcp)) {
 390                         tprints(", ");
 391
 392                         return 0;
 393                 }
 394
 395                 if (umove_or_printaddr(tcp, data, &dq))
 396                         break;
 397                 PRINT_FIELD_D("{", dq, qs_version);
 398                 if (!abbrev(tcp)) {
 399                         tprints(", qs_flags=");
 400                         printflags(xfs_quota_flags,
 401                                    dq.qs_flags, "XFS_QUOTA_???");
 402                         PRINT_FIELD_U(", ", dq, qs_incoredqs);
 403                         PRINT_FIELD_U(", qs_uquota={", dq.qs_uquota, qfs_ino);
 404                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nblks);
 405                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nextents);
 406                         PRINT_FIELD_U("}, qs_gquota={", dq.qs_gquota, qfs_ino);
 407                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nblks);
 408                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nextents);
 409                         PRINT_FIELD_U("}, qs_pquota={", dq.qs_pquota, qfs_ino);
 410                         PRINT_FIELD_U(", ", dq.qs_pquota, qfs_nblks);
 411                         PRINT_FIELD_U(", ", dq.qs_pquota, qfs_nextents);
 412                         PRINT_FIELD_D("}, ", dq, qs_btimelimit);
 413                         PRINT_FIELD_D(", ", dq, qs_itimelimit);
 414                         PRINT_FIELD_D(", ", dq, qs_rtbtimelimit);
 415                         PRINT_FIELD_U(", ", dq, qs_bwarnlimit);
 416                         PRINT_FIELD_U(", ", dq, qs_iwarnlimit);
 417                 } else {
 418                         tprints(", ...");
 419                 }
 420                 tprints("}");
 421                 break;
 422         }
 423         case Q_XQUOTAON:
 424         case Q_XQUOTAOFF:
 425         {
 426                 uint32_t flag;
 427
 428                 tprints(", ");
 429
 430                 if (umove_or_printaddr(tcp, data, &flag))
 431                         break;
 432                 tprints("[");
 433                 printflags(xfs_quota_flags, flag, "XFS_QUOTA_???");
 434                 tprints("]");
 435                 break;
 436         }
 437         case Q_XQUOTARM:
 438         {
 439                 uint32_t flag;
 440
 441                 tprints(", ");
 442
 443                 if (umove_or_printaddr(tcp, data, &flag))
 444                         break;
 445                 tprints("[");
 446                 printflags(xfs_dqblk_flags, flag, "XFS_???_QUOTA");
 447                 tprints("]");
 448                 break;
 449         }
 450         default:
 451                 printuid(", ", id);
 452                 tprints(", ");
 453                 printaddr(data);
 454                 break;
 455         }
 456         return RVAL_DECODED;
 457 }
 458
 459 SYS_FUNC(quotactl)
 460 {
 461         /*
 462          * The Linux kernel only looks at the low 32 bits of command and id
 463          * arguments, but on some 64-bit architectures (s390x) this word
 464          * will have been sign-extended when we see it.  The high 1 bits
 465          * don't mean anything, so don't confuse the output with them.
 466          */
 467         uint32_t qcmd = tcp->u_arg[0];
 468         uint32_t cmd = QCMD_CMD(qcmd);
 469         uint32_t type = QCMD_TYPE(qcmd);
 470         uint32_t id = tcp->u_arg[2];
 471
 472         if (entering(tcp)) {
 473                 tprints("QCMD(");
 474                 printxval(quotacmds, cmd, "Q_???");
 475                 tprints(", ");
 476                 printxval(quotatypes, type, "???QUOTA");
 477                 tprints("), ");
 478                 printpath(tcp, tcp->u_arg[1]);
 479         }
 480         return decode_cmd_data(tcp, id, cmd, tcp->u_arg[3]);
 481 }