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         uint64_t dqb_bhardlimit;
  60         uint64_t dqb_bsoftlimit;
  61         uint64_t dqb_curspace;
  62         uint64_t dqb_ihardlimit;
  63         uint64_t dqb_isoftlimit;
  64         uint64_t dqb_curinodes;
  65         uint64_t dqb_btime;
  66         uint64_t dqb_itime;
  67         uint32_t dqb_valid;
  68 } ATTRIBUTE_PACKED;
  69
  70 struct if_nextdqblk {
  71         uint64_t dqb_bhardlimit;
  72         uint64_t dqb_bsoftlimit;
  73         uint64_t dqb_curspace;
  74         uint64_t dqb_ihardlimit;
  75         uint64_t dqb_isoftlimit;
  76         uint64_t dqb_curinodes;
  77         uint64_t dqb_btime;
  78         uint64_t dqb_itime;
  79         uint32_t dqb_valid;
  80         uint32_t dqb_id;
  81 };
  82
  83 struct xfs_dqblk {
  84         int8_t  d_version;              /* version of this structure */
  85         int8_t  d_flags;                /* XFS_{USER,PROJ,GROUP}_QUOTA */
  86         uint16_t d_fieldmask;           /* field specifier */
  87         uint32_t d_id;                  /* user, project, or group ID */
  88         uint64_t d_blk_hardlimit;       /* absolute limit on disk blks */
  89         uint64_t d_blk_softlimit;       /* preferred limit on disk blks */
  90         uint64_t d_ino_hardlimit;       /* maximum # allocated inodes */
  91         uint64_t d_ino_softlimit;       /* preferred inode limit */
  92         uint64_t d_bcount;              /* # disk blocks owned by the user */
  93         uint64_t d_icount;              /* # inodes owned by the user */
  94         int32_t d_itimer;               /* zero if within inode limits */
  95         int32_t d_btimer;               /* similar to above; for disk blocks */
  96         uint16_t d_iwarns;              /* # warnings issued wrt num inodes */
  97         uint16_t d_bwarns;              /* # warnings issued wrt disk blocks */
  98         int32_t d_padding2;             /* padding2 - for future use */
  99         uint64_t d_rtb_hardlimit;       /* absolute limit on realtime blks */
 100         uint64_t d_rtb_softlimit;       /* preferred limit on RT disk blks */
 101         uint64_t d_rtbcount;            /* # realtime blocks owned */
 102         int32_t d_rtbtimer;             /* similar to above; for RT disk blks */
 103         uint16_t d_rtbwarns;            /* # warnings issued wrt RT disk blks */
 104         int16_t d_padding3;             /* padding3 - for future use */
 105         char    d_padding4[8];          /* yet more padding */
 106 };
 107
 108 struct if_dqinfo {
 109         uint64_t dqi_bgrace;
 110         uint64_t dqi_igrace;
 111         uint32_t dqi_flags;
 112         uint32_t dqi_valid;
 113 };
 114
 115 typedef struct fs_qfilestat {
 116         uint64_t qfs_ino;       /* inode number */
 117         uint64_t qfs_nblks;     /* number of BBs 512-byte-blks */
 118         uint32_t qfs_nextents;  /* number of extents */
 119 } fs_qfilestat_t;
 120
 121 struct xfs_dqstats {
 122         int8_t  qs_version;             /* version number for future changes */
 123         uint16_t qs_flags;              /* XFS_QUOTA_{U,P,G}DQ_{ACCT,ENFD} */
 124         int8_t  qs_pad;                 /* unused */
 125         fs_qfilestat_t qs_uquota;       /* user quota storage information */
 126         fs_qfilestat_t qs_gquota;       /* group quota storage information */
 127         uint32_t qs_incoredqs;          /* number of dquots incore */
 128         int32_t qs_btimelimit;          /* limit for blks timer */
 129         int32_t qs_itimelimit;          /* limit for inodes timer */
 130         int32_t qs_rtbtimelimit;        /* limit for rt blks timer */
 131         uint16_t qs_bwarnlimit;         /* limit for num warnings */
 132         uint16_t qs_iwarnlimit;         /* limit for num warnings */
 133 };
 134
 135 struct fs_qfilestatv {
 136         uint64_t qfs_ino, qfs_nblks;
 137         uint32_t qfs_nextents, qfs_pad;
 138 };
 139
 140 struct fs_quota_statv {
 141         int8_t qs_version;
 142         uint8_t qs_pad1;
 143         uint16_t qs_flags;
 144         uint32_t qs_incoredqs;
 145         struct fs_qfilestatv qs_uquota;
 146         struct fs_qfilestatv qs_gquota;
 147         struct fs_qfilestatv qs_pquota;
 148         int32_t qs_btimelimit;
 149         int32_t qs_itimelimit;
 150         int32_t qs_rtbtimelimit;
 151         uint16_t qs_bwarnlimit;
 152         uint16_t qs_iwarnlimit;
 153         uint64_t qs_pad2[8];
 154 };
 155
 156 #define PRINT_FIELD_D(prefix, where, field)     \
 157         tprintf("%s%s=%lld", (prefix), #field,  \
 158                 sign_extend_unsigned_to_ll((where).field))
 159
 160 #define PRINT_FIELD_U(prefix, where, field)     \
 161         tprintf("%s%s=%llu", (prefix), #field,  \
 162                 zero_extend_signed_to_ull((where).field))
 163
 164 #define PRINT_FIELD_X(prefix, where, field)     \
 165         tprintf("%s%s=%#llx", (prefix), #field, \
 166                 zero_extend_signed_to_ull((where).field))
 167
 168 static int
 169 decode_cmd_data(struct tcb *tcp, uint32_t id, uint32_t cmd, kernel_ulong_t data)
 170 {
 171         switch (cmd) {
 172         case Q_QUOTAOFF:
 173         case Q_SYNC:
 174         case Q_XQUOTASYNC:
 175                 break;
 176         case Q_QUOTAON:
 177                 tprints(", ");
 178                 printxval(quota_formats, id, "QFMT_VFS_???");
 179                 tprints(", ");
 180                 printpath(tcp, data);
 181                 break;
 182         case Q_GETQUOTA:
 183                 if (entering(tcp)) {
 184                         printuid(", ", id);
 185                         tprints(", ");
 186
 187                         return 0;
 188                 }
 189
 190                 /* Fall-through */
 191         case Q_SETQUOTA:
 192         {
 193                 struct if_dqblk dq;
 194
 195                 if (entering(tcp)) {
 196                         printuid(", ", id);
 197                         tprints(", ");
 198                 }
 199
 200                 if (umove_or_printaddr(tcp, data, &dq))
 201                         break;
 202                 PRINT_FIELD_U("{", dq, dqb_bhardlimit);
 203                 PRINT_FIELD_U(", ", dq, dqb_bsoftlimit);
 204                 PRINT_FIELD_U(", ", dq, dqb_curspace);
 205                 PRINT_FIELD_U(", ", dq, dqb_ihardlimit);
 206                 PRINT_FIELD_U(", ", dq, dqb_isoftlimit);
 207                 PRINT_FIELD_U(", ", dq, dqb_curinodes);
 208                 if (!abbrev(tcp)) {
 209                         PRINT_FIELD_U(", ", dq, dqb_btime);
 210                         PRINT_FIELD_U(", ", dq, dqb_itime);
 211                         tprints(", dqb_valid=");
 212                         printflags(if_dqblk_valid,
 213                                    dq.dqb_valid, "QIF_???");
 214                 } else {
 215                         tprints(", ...");
 216                 }
 217                 tprints("}");
 218                 break;
 219         }
 220         case Q_GETNEXTQUOTA:
 221         {
 222                 struct if_nextdqblk dq;
 223
 224                 if (entering(tcp)) {
 225                         printuid(", ", id);
 226                         tprints(", ");
 227
 228                         return 0;
 229                 }
 230
 231                 if (umove_or_printaddr(tcp, data, &dq))
 232                         break;
 233                 PRINT_FIELD_U("{", dq, dqb_bhardlimit);
 234                 PRINT_FIELD_U(", ", dq, dqb_bsoftlimit);
 235                 PRINT_FIELD_U(", ", dq, dqb_curspace);
 236                 PRINT_FIELD_U(", ", dq, dqb_ihardlimit);
 237                 PRINT_FIELD_U(", ", dq, dqb_isoftlimit);
 238                 PRINT_FIELD_U(", ", dq, dqb_curinodes);
 239                 if (!abbrev(tcp)) {
 240                         PRINT_FIELD_U(", ", dq, dqb_btime);
 241                         PRINT_FIELD_U(", ", dq, dqb_itime);
 242                         tprints(", dqb_valid=");
 243                         printflags(if_dqblk_valid,
 244                                    dq.dqb_valid, "QIF_???");
 245                         PRINT_FIELD_U(", ", dq, dqb_id);
 246                 } else {
 247                         PRINT_FIELD_U(", ", dq, dqb_id);
 248                         tprints(", ...");
 249                 }
 250                 tprints("}");
 251                 break;
 252         }
 253         case Q_XGETQUOTA:
 254         case Q_XGETNEXTQUOTA:
 255                 if (entering(tcp)) {
 256                         printuid(", ", id);
 257                         tprints(", ");
 258
 259                         return 0;
 260                 }
 261
 262                 /* Fall-through */
 263         case Q_XSETQLIM:
 264         {
 265                 struct xfs_dqblk dq;
 266
 267                 if (entering(tcp)) {
 268                         printuid(", ", id);
 269                         tprints(", ");
 270                 }
 271
 272                 if (umove_or_printaddr(tcp, data, &dq))
 273                         break;
 274                 PRINT_FIELD_D("{", dq, d_version);
 275                 tprints(", d_flags=");
 276                 printflags(xfs_dqblk_flags,
 277                            (uint8_t) dq.d_flags, "XFS_???_QUOTA");
 278                 PRINT_FIELD_X(", ", dq, d_fieldmask);
 279                 PRINT_FIELD_U(", ", dq, d_id);
 280                 PRINT_FIELD_U(", ", dq, d_blk_hardlimit);
 281                 PRINT_FIELD_U(", ", dq, d_blk_softlimit);
 282                 PRINT_FIELD_U(", ", dq, d_ino_hardlimit);
 283                 PRINT_FIELD_U(", ", dq, d_ino_softlimit);
 284                 PRINT_FIELD_U(", ", dq, d_bcount);
 285                 PRINT_FIELD_U(", ", dq, d_icount);
 286                 if (!abbrev(tcp)) {
 287                         PRINT_FIELD_D(", ", dq, d_itimer);
 288                         PRINT_FIELD_D(", ", dq, d_btimer);
 289                         PRINT_FIELD_U(", ", dq, d_iwarns);
 290                         PRINT_FIELD_U(", ", dq, d_bwarns);
 291                         PRINT_FIELD_U(", ", dq, d_rtb_hardlimit);
 292                         PRINT_FIELD_U(", ", dq, d_rtb_softlimit);
 293                         PRINT_FIELD_U(", ", dq, d_rtbcount);
 294                         PRINT_FIELD_D(", ", dq, d_rtbtimer);
 295                         PRINT_FIELD_U(", ", dq, d_rtbwarns);
 296                 } else {
 297                         tprints(", ...");
 298                 }
 299                 tprints("}");
 300                 break;
 301         }
 302         case Q_GETFMT:
 303         {
 304                 uint32_t fmt;
 305
 306                 if (entering(tcp)) {
 307                         tprints(", ");
 308
 309                         return 0;
 310                 }
 311
 312                 if (umove_or_printaddr(tcp, data, &fmt))
 313                         break;
 314                 tprints("[");
 315                 printxval(quota_formats, fmt, "QFMT_VFS_???");
 316                 tprints("]");
 317                 break;
 318         }
 319         case Q_GETINFO:
 320                 if (entering(tcp)) {
 321                         tprints(", ");
 322
 323                         return 0;
 324                 }
 325
 326                 /* Fall-through */
 327         case Q_SETINFO:
 328         {
 329                 struct if_dqinfo dq;
 330
 331                 if (entering(tcp))
 332                         tprints(", ");
 333
 334                 if (umove_or_printaddr(tcp, data, &dq))
 335                         break;
 336                 PRINT_FIELD_U("{", dq, dqi_bgrace);
 337                 PRINT_FIELD_U(", ", dq, dqi_igrace);
 338                 tprints(", dqi_flags=");
 339                 printflags(if_dqinfo_flags, dq.dqi_flags, "DQF_???");
 340                 tprints(", dqi_valid=");
 341                 printflags(if_dqinfo_valid, dq.dqi_valid, "IIF_???");
 342                 tprints("}");
 343                 break;
 344         }
 345         case Q_XGETQSTAT:
 346         {
 347                 struct xfs_dqstats dq;
 348
 349                 if (entering(tcp)) {
 350                         tprints(", ");
 351
 352                         return 0;
 353                 }
 354
 355                 if (umove_or_printaddr(tcp, data, &dq))
 356                         break;
 357                 PRINT_FIELD_D("{", dq, qs_version);
 358                 if (!abbrev(tcp)) {
 359                         tprints(", qs_flags=");
 360                         printflags(xfs_quota_flags,
 361                                    dq.qs_flags, "XFS_QUOTA_???");
 362                         PRINT_FIELD_U(", ", dq, qs_incoredqs);
 363                         PRINT_FIELD_U(", qs_uquota={", dq.qs_uquota, qfs_ino);
 364                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nblks);
 365                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nextents);
 366                         PRINT_FIELD_U("}, qs_gquota={", dq.qs_gquota, qfs_ino);
 367                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nblks);
 368                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nextents);
 369                         PRINT_FIELD_D("}, ", dq, qs_btimelimit);
 370                         PRINT_FIELD_D(", ", dq, qs_itimelimit);
 371                         PRINT_FIELD_D(", ", dq, qs_rtbtimelimit);
 372                         PRINT_FIELD_U(", ", dq, qs_bwarnlimit);
 373                         PRINT_FIELD_U(", ", dq, qs_iwarnlimit);
 374                 } else {
 375                         tprints(", ...");
 376                 }
 377                 tprints("}");
 378                 break;
 379         }
 380         case Q_XGETQSTATV:
 381         {
 382                 struct fs_quota_statv dq;
 383
 384                 if (entering(tcp)) {
 385                         tprints(", ");
 386
 387                         return 0;
 388                 }
 389
 390                 if (umove_or_printaddr(tcp, data, &dq))
 391                         break;
 392                 PRINT_FIELD_D("{", dq, qs_version);
 393                 if (!abbrev(tcp)) {
 394                         tprints(", qs_flags=");
 395                         printflags(xfs_quota_flags,
 396                                    dq.qs_flags, "XFS_QUOTA_???");
 397                         PRINT_FIELD_U(", ", dq, qs_incoredqs);
 398                         PRINT_FIELD_U(", qs_uquota={", dq.qs_uquota, qfs_ino);
 399                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nblks);
 400                         PRINT_FIELD_U(", ", dq.qs_uquota, qfs_nextents);
 401                         PRINT_FIELD_U("}, qs_gquota={", dq.qs_gquota, qfs_ino);
 402                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nblks);
 403                         PRINT_FIELD_U(", ", dq.qs_gquota, qfs_nextents);
 404                         PRINT_FIELD_U("}, qs_pquota={", dq.qs_pquota, qfs_ino);
 405                         PRINT_FIELD_U(", ", dq.qs_pquota, qfs_nblks);
 406                         PRINT_FIELD_U(", ", dq.qs_pquota, qfs_nextents);
 407                         PRINT_FIELD_D("}, ", dq, qs_btimelimit);
 408                         PRINT_FIELD_D(", ", dq, qs_itimelimit);
 409                         PRINT_FIELD_D(", ", dq, qs_rtbtimelimit);
 410                         PRINT_FIELD_U(", ", dq, qs_bwarnlimit);
 411                         PRINT_FIELD_U(", ", dq, qs_iwarnlimit);
 412                 } else {
 413                         tprints(", ...");
 414                 }
 415                 tprints("}");
 416                 break;
 417         }
 418         case Q_XQUOTAON:
 419         case Q_XQUOTAOFF:
 420         {
 421                 uint32_t flag;
 422
 423                 tprints(", ");
 424
 425                 if (umove_or_printaddr(tcp, data, &flag))
 426                         break;
 427                 tprints("[");
 428                 printflags(xfs_quota_flags, flag, "XFS_QUOTA_???");
 429                 tprints("]");
 430                 break;
 431         }
 432         case Q_XQUOTARM:
 433         {
 434                 uint32_t flag;
 435
 436                 tprints(", ");
 437
 438                 if (umove_or_printaddr(tcp, data, &flag))
 439                         break;
 440                 tprints("[");
 441                 printflags(xfs_dqblk_flags, flag, "XFS_???_QUOTA");
 442                 tprints("]");
 443                 break;
 444         }
 445         default:
 446                 printuid(", ", id);
 447                 tprints(", ");
 448                 printaddr(data);
 449                 break;
 450         }
 451         return RVAL_DECODED;
 452 }
 453
 454 SYS_FUNC(quotactl)
 455 {
 456         /*
 457          * The Linux kernel only looks at the low 32 bits of command and id
 458          * arguments, but on some 64-bit architectures (s390x) this word
 459          * will have been sign-extended when we see it.  The high 1 bits
 460          * don't mean anything, so don't confuse the output with them.
 461          */
 462         uint32_t qcmd = tcp->u_arg[0];
 463         uint32_t cmd = QCMD_CMD(qcmd);
 464         uint32_t type = QCMD_TYPE(qcmd);
 465         uint32_t id = tcp->u_arg[2];
 466
 467         if (entering(tcp)) {
 468                 tprints("QCMD(");
 469                 printxval(quotacmds, cmd, "Q_???");
 470                 tprints(", ");
 471                 printxval(quotatypes, type, "???QUOTA");
 472                 tprints("), ");
 473                 printpath(tcp, tcp->u_arg[1]);
 474         }
 475         return decode_cmd_data(tcp, id, cmd, tcp->u_arg[3]);
 476 }