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 struct if_dqblk
  53 {
  54         uint64_t dqb_bhardlimit;
  55         uint64_t dqb_bsoftlimit;
  56         uint64_t dqb_curspace;
  57         uint64_t dqb_ihardlimit;
  58         uint64_t dqb_isoftlimit;
  59         uint64_t dqb_curinodes;
  60         uint64_t dqb_btime;
  61         uint64_t dqb_itime;
  62         uint32_t dqb_valid;
  63 };
  64
  65 struct if_nextdqblk {
  66         uint64_t dqb_bhardlimit;
  67         uint64_t dqb_bsoftlimit;
  68         uint64_t dqb_curspace;
  69         uint64_t dqb_ihardlimit;
  70         uint64_t dqb_isoftlimit;
  71         uint64_t dqb_curinodes;
  72         uint64_t dqb_btime;
  73         uint64_t dqb_itime;
  74         uint32_t dqb_valid;
  75         uint32_t dqb_id;
  76 };
  77
  78 struct v1_dqblk
  79 {
  80         uint32_t dqb_bhardlimit;        /* absolute limit on disk blks alloc */
  81         uint32_t dqb_bsoftlimit;        /* preferred limit on disk blks */
  82         uint32_t dqb_curblocks;         /* current block count */
  83         uint32_t dqb_ihardlimit;        /* maximum # allocated inodes */
  84         uint32_t dqb_isoftlimit;        /* preferred inode limit */
  85         uint32_t dqb_curinodes;         /* current # allocated inodes */
  86         time_t  dqb_btime;              /* time limit for excessive disk use */
  87         time_t  dqb_itime;              /* time limit for excessive files */
  88 };
  89
  90 struct v2_dqblk
  91 {
  92         unsigned int dqb_ihardlimit;
  93         unsigned int dqb_isoftlimit;
  94         unsigned int dqb_curinodes;
  95         unsigned int dqb_bhardlimit;
  96         unsigned int dqb_bsoftlimit;
  97         uint64_t dqb_curspace;
  98         time_t  dqb_btime;
  99         time_t  dqb_itime;
 100 };
 101
 102 struct xfs_dqblk
 103 {
 104         int8_t  d_version;              /* version of this structure */
 105         int8_t  d_flags;                /* XFS_{USER,PROJ,GROUP}_QUOTA */
 106         uint16_t d_fieldmask;           /* field specifier */
 107         uint32_t d_id;                  /* user, project, or group ID */
 108         uint64_t d_blk_hardlimit;       /* absolute limit on disk blks */
 109         uint64_t d_blk_softlimit;       /* preferred limit on disk blks */
 110         uint64_t d_ino_hardlimit;       /* maximum # allocated inodes */
 111         uint64_t d_ino_softlimit;       /* preferred inode limit */
 112         uint64_t d_bcount;              /* # disk blocks owned by the user */
 113         uint64_t d_icount;              /* # inodes owned by the user */
 114         int32_t d_itimer;               /* zero if within inode limits */
 115         int32_t d_btimer;               /* similar to above; for disk blocks */
 116         uint16_t d_iwarns;              /* # warnings issued wrt num inodes */
 117         uint16_t d_bwarns;              /* # warnings issued wrt disk blocks */
 118         int32_t d_padding2;             /* padding2 - for future use */
 119         uint64_t d_rtb_hardlimit;       /* absolute limit on realtime blks */
 120         uint64_t d_rtb_softlimit;       /* preferred limit on RT disk blks */
 121         uint64_t d_rtbcount;            /* # realtime blocks owned */
 122         int32_t d_rtbtimer;             /* similar to above; for RT disk blks */
 123         uint16_t d_rtbwarns;            /* # warnings issued wrt RT disk blks */
 124         int16_t d_padding3;             /* padding3 - for future use */
 125         char    d_padding4[8];          /* yet more padding */
 126 };
 127
 128 struct if_dqinfo
 129 {
 130         uint64_t dqi_bgrace;
 131         uint64_t dqi_igrace;
 132         uint32_t dqi_flags;
 133         uint32_t dqi_valid;
 134 };
 135
 136 struct v2_dqinfo
 137 {
 138         unsigned int dqi_bgrace;
 139         unsigned int dqi_igrace;
 140         unsigned int dqi_flags;
 141         unsigned int dqi_blocks;
 142         unsigned int dqi_free_blk;
 143         unsigned int dqi_free_entry;
 144 };
 145
 146 struct v1_dqstats
 147 {
 148         uint32_t lookups;
 149         uint32_t drops;
 150         uint32_t reads;
 151         uint32_t writes;
 152         uint32_t cache_hits;
 153         uint32_t allocated_dquots;
 154         uint32_t free_dquots;
 155         uint32_t syncs;
 156 };
 157
 158 struct v2_dqstats
 159 {
 160         uint32_t lookups;
 161         uint32_t drops;
 162         uint32_t reads;
 163         uint32_t writes;
 164         uint32_t cache_hits;
 165         uint32_t allocated_dquots;
 166         uint32_t free_dquots;
 167         uint32_t syncs;
 168         uint32_t version;
 169 };
 170
 171 typedef struct fs_qfilestat
 172 {
 173         uint64_t qfs_ino;       /* inode number */
 174         uint64_t qfs_nblks;     /* number of BBs 512-byte-blks */
 175         uint32_t qfs_nextents;  /* number of extents */
 176 } fs_qfilestat_t;
 177
 178 struct xfs_dqstats
 179 {
 180         int8_t  qs_version;             /* version number for future changes */
 181         uint16_t qs_flags;              /* XFS_QUOTA_{U,P,G}DQ_{ACCT,ENFD} */
 182         int8_t  qs_pad;                 /* unused */
 183         fs_qfilestat_t qs_uquota;       /* user quota storage information */
 184         fs_qfilestat_t qs_gquota;       /* group quota storage information */
 185         uint32_t qs_incoredqs;          /* number of dquots incore */
 186         int32_t qs_btimelimit;          /* limit for blks timer */
 187         int32_t qs_itimelimit;          /* limit for inodes timer */
 188         int32_t qs_rtbtimelimit;        /* limit for rt blks timer */
 189         uint16_t qs_bwarnlimit;         /* limit for num warnings */
 190         uint16_t qs_iwarnlimit;         /* limit for num warnings */
 191 };
 192
 193 struct fs_qfilestatv {
 194         uint64_t qfs_ino, qfs_nblks;
 195         uint32_t qfs_nextents, qfs_pad;
 196 };
 197
 198 struct fs_quota_statv {
 199         int8_t qs_version;
 200         uint8_t qs_pad1;
 201         uint16_t qs_flags;
 202         uint32_t qs_incoredqs;
 203         struct fs_qfilestatv qs_uquota;
 204         struct fs_qfilestatv qs_gquota;
 205         struct fs_qfilestatv qs_pquota;
 206         int32_t qs_btimelimit;
 207         int32_t qs_itimelimit;
 208         int32_t qs_rtbtimelimit;
 209         uint16_t qs_bwarnlimit;
 210         uint16_t qs_iwarnlimit;
 211         uint64_t qs_pad2[8];
 212 };
 213
 214 static int
 215 decode_cmd_data(struct tcb *tcp, uint32_t id, uint32_t cmd, unsigned long data)
 216 {
 217         switch (cmd) {
 218         case Q_QUOTAOFF:
 219         case Q_SYNC:
 220         case Q_XQUOTASYNC:
 221                 break;
 222         case Q_GETQUOTA:
 223                 if (entering(tcp)) {
 224                         printuid(", ", id);
 225                         tprints(", ");
 226
 227                         return 0;
 228                 }
 229
 230                 /* Fall-through */
 231         case Q_SETQUOTA:
 232         {
 233                 struct if_dqblk dq;
 234
 235                 if (entering(tcp)) {
 236                         printuid(", ", id);
 237                         tprints(", ");
 238                 }
 239
 240                 if (umove_or_printaddr(tcp, data, &dq))
 241                         break;
 242                 tprintf("{dqb_bhardlimit=%" PRIu64 ", ", dq.dqb_bhardlimit);
 243                 tprintf("dqb_bsoftlimit=%" PRIu64 ", ", dq.dqb_bsoftlimit);
 244                 tprintf("dqb_curspace=%" PRIu64 ", ", dq.dqb_curspace);
 245                 tprintf("dqb_ihardlimit=%" PRIu64 ", ", dq.dqb_ihardlimit);
 246                 tprintf("dqb_isoftlimit=%" PRIu64 ", ", dq.dqb_isoftlimit);
 247                 tprintf("dqb_curinodes=%" PRIu64 ", ", dq.dqb_curinodes);
 248                 if (!abbrev(tcp)) {
 249                         tprintf("dqb_btime=%" PRIu64 ", ", dq.dqb_btime);
 250                         tprintf("dqb_itime=%" PRIu64 ", ", dq.dqb_itime);
 251                         tprints("dqb_valid=");
 252                         printflags(if_dqblk_valid,
 253                                    dq.dqb_valid, "QIF_???");
 254                         tprints("}");
 255                 } else
 256                         tprints("...}");
 257                 break;
 258         }
 259         case Q_GETNEXTQUOTA:
 260         {
 261                 struct if_nextdqblk dq;
 262
 263                 if (entering(tcp)) {
 264                         printuid(", ", id);
 265                         tprints(", ");
 266
 267                         return 0;
 268                 }
 269
 270                 if (umove_or_printaddr(tcp, data, &dq))
 271                         break;
 272                 tprintf("{dqb_bhardlimit=%" PRIu64 ", ", dq.dqb_bhardlimit);
 273                 tprintf("dqb_bsoftlimit=%" PRIu64 ", ", dq.dqb_bsoftlimit);
 274                 tprintf("dqb_curspace=%" PRIu64 ", ", dq.dqb_curspace);
 275                 tprintf("dqb_ihardlimit=%" PRIu64 ", ", dq.dqb_ihardlimit);
 276                 tprintf("dqb_isoftlimit=%" PRIu64 ", ", dq.dqb_isoftlimit);
 277                 tprintf("dqb_curinodes=%" PRIu64 ", ", dq.dqb_curinodes);
 278                 if (!abbrev(tcp)) {
 279                         tprintf("dqb_btime=%" PRIu64 ", ", dq.dqb_btime);
 280                         tprintf("dqb_itime=%" PRIu64 ", ", dq.dqb_itime);
 281                         tprints("dqb_valid=");
 282                         printflags(if_dqblk_valid,
 283                                    dq.dqb_valid, "QIF_???");
 284                         tprintf(", dqb_id=%u}", dq.dqb_id);
 285                 } else
 286                         tprintf("dqb_id=%u, ...}", dq.dqb_id);
 287                 break;
 288         }
 289         case Q_V1_GETQUOTA:
 290                 if (entering(tcp)) {
 291                         printuid(", ", id);
 292                         tprints(", ");
 293
 294                         return 0;
 295                 }
 296
 297                 /* Fall-through */
 298         case Q_V1_SETQUOTA:
 299         {
 300                 struct v1_dqblk dq;
 301
 302                 if (entering(tcp)) {
 303                         printuid(", ", id);
 304                         tprints(", ");
 305                 }
 306
 307                 if (umove_or_printaddr(tcp, data, &dq))
 308                         break;
 309                 tprintf("{dqb_bhardlimit=%u, ", dq.dqb_bhardlimit);
 310                 tprintf("dqb_bsoftlimit=%u, ", dq.dqb_bsoftlimit);
 311                 tprintf("dqb_curblocks=%u, ", dq.dqb_curblocks);
 312                 tprintf("dqb_ihardlimit=%u, ", dq.dqb_ihardlimit);
 313                 tprintf("dqb_isoftlimit=%u, ", dq.dqb_isoftlimit);
 314                 tprintf("dqb_curinodes=%u, ", dq.dqb_curinodes);
 315                 tprintf("dqb_btime=%lu, ", (long) dq.dqb_btime);
 316                 tprintf("dqb_itime=%lu}", (long) dq.dqb_itime);
 317                 break;
 318         }
 319         case Q_V2_GETQUOTA:
 320                 if (entering(tcp)) {
 321                         printuid(", ", id);
 322                         tprints(", ");
 323
 324                         return 0;
 325                 }
 326
 327                 /* Fall-through */
 328         case Q_V2_SETQUOTA:
 329         {
 330                 struct v2_dqblk dq;
 331
 332                 if (entering(tcp)) {
 333                         printuid(", ", id);
 334                         tprints(", ");
 335                 }
 336
 337                 if (umove_or_printaddr(tcp, data, &dq))
 338                         break;
 339                 tprintf("{dqb_ihardlimit=%u, ", dq.dqb_ihardlimit);
 340                 tprintf("dqb_isoftlimit=%u, ", dq.dqb_isoftlimit);
 341                 tprintf("dqb_curinodes=%u, ", dq.dqb_curinodes);
 342                 tprintf("dqb_bhardlimit=%u, ", dq.dqb_bhardlimit);
 343                 tprintf("dqb_bsoftlimit=%u, ", dq.dqb_bsoftlimit);
 344                 tprintf("dqb_curspace=%" PRIu64 ", ", dq.dqb_curspace);
 345                 tprintf("dqb_btime=%lu, ", (long) dq.dqb_btime);
 346                 tprintf("dqb_itime=%lu}", (long) dq.dqb_itime);
 347                 break;
 348         }
 349         case Q_XGETQUOTA:
 350         case Q_XGETNEXTQUOTA:
 351                 if (entering(tcp)) {
 352                         printuid(", ", id);
 353                         tprints(", ");
 354
 355                         return 0;
 356                 }
 357
 358                 /* Fall-through */
 359         case Q_XSETQLIM:
 360         {
 361                 struct xfs_dqblk dq;
 362
 363                 if (entering(tcp)) {
 364                         printuid(", ", id);
 365                         tprints(", ");
 366                 }
 367
 368                 if (umove_or_printaddr(tcp, data, &dq))
 369                         break;
 370                 tprintf("{d_version=%d, ", dq.d_version);
 371                 tprints("d_flags=");
 372                 printflags(xfs_dqblk_flags,
 373                            (uint8_t) dq.d_flags, "XFS_???_QUOTA");
 374                 tprintf(", d_fieldmask=%#x, ", dq.d_fieldmask);
 375                 tprintf("d_id=%u, ", dq.d_id);
 376                 tprintf("d_blk_hardlimit=%" PRIu64 ", ", dq.d_blk_hardlimit);
 377                 tprintf("d_blk_softlimit=%" PRIu64 ", ", dq.d_blk_softlimit);
 378                 tprintf("d_ino_hardlimit=%" PRIu64 ", ", dq.d_ino_hardlimit);
 379                 tprintf("d_ino_softlimit=%" PRIu64 ", ", dq.d_ino_softlimit);
 380                 tprintf("d_bcount=%" PRIu64 ", ", dq.d_bcount);
 381                 tprintf("d_icount=%" PRIu64 ", ", dq.d_icount);
 382                 if (!abbrev(tcp)) {
 383                         tprintf("d_itimer=%d, ", dq.d_itimer);
 384                         tprintf("d_btimer=%d, ", dq.d_btimer);
 385                         tprintf("d_iwarns=%u, ", dq.d_iwarns);
 386                         tprintf("d_bwarns=%u, ", dq.d_bwarns);
 387                         tprintf("d_rtbcount=%" PRIu64 ", ", dq.d_rtbcount);
 388                         tprintf("d_rtbtimer=%d, ", dq.d_rtbtimer);
 389                         tprintf("d_rtbwarns=%u}", dq.d_rtbwarns);
 390                 } else
 391                         tprints("...}");
 392                 break;
 393         }
 394         case Q_GETFMT:
 395         {
 396                 uint32_t fmt;
 397
 398                 if (entering(tcp)) {
 399                         tprints(", ");
 400
 401                         return 0;
 402                 }
 403
 404                 if (umove_or_printaddr(tcp, data, &fmt))
 405                         break;
 406                 tprints("[");
 407                 printxval(quota_formats, fmt, "QFMT_VFS_???");
 408                 tprints("]");
 409                 break;
 410         }
 411         case Q_GETINFO:
 412                 if (entering(tcp)) {
 413                         tprints(", ");
 414
 415                         return 0;
 416                 }
 417
 418                 /* Fall-through */
 419         case Q_SETINFO:
 420         {
 421                 struct if_dqinfo dq;
 422
 423                 if (entering(tcp))
 424                         tprints(", ");
 425
 426                 if (umove_or_printaddr(tcp, data, &dq))
 427                         break;
 428                 tprintf("{dqi_bgrace=%" PRIu64 ", ", dq.dqi_bgrace);
 429                 tprintf("dqi_igrace=%" PRIu64 ", ", dq.dqi_igrace);
 430                 tprints("dqi_flags=");
 431                 printflags(if_dqinfo_flags, dq.dqi_flags, "DQF_???");
 432                 tprints(", dqi_valid=");
 433                 printflags(if_dqinfo_valid, dq.dqi_valid, "IIF_???");
 434                 tprints("}");
 435                 break;
 436         }
 437         case Q_V2_GETINFO:
 438                 if (entering(tcp)) {
 439                         tprints(", ");
 440
 441                         return 0;
 442                 }
 443
 444                 /* Fall-through */
 445         case Q_V2_SETINFO:
 446         {
 447                 struct v2_dqinfo dq;
 448
 449                 if (entering(tcp))
 450                         tprints(", ");
 451
 452                 if (umove_or_printaddr(tcp, data, &dq))
 453                         break;
 454                 tprintf("{dqi_bgrace=%u, ", dq.dqi_bgrace);
 455                 tprintf("dqi_igrace=%u, ", dq.dqi_igrace);
 456                 tprints("dqi_flags=");
 457                 printflags(if_dqinfo_flags, dq.dqi_flags, "DQF_???");
 458                 tprintf(", dqi_blocks=%u, ", dq.dqi_blocks);
 459                 tprintf("dqi_free_blk=%u, ", dq.dqi_free_blk);
 460                 tprintf("dqi_free_entry=%u}", dq.dqi_free_entry);
 461                 break;
 462         }
 463         case Q_V1_GETSTATS:
 464         {
 465                 struct v1_dqstats dq;
 466
 467                 if (entering(tcp)) {
 468                         tprints(", ");
 469
 470                         return 0;
 471                 }
 472
 473                 if (umove_or_printaddr(tcp, data, &dq))
 474                         break;
 475                 tprintf("{lookups=%u, ", dq.lookups);
 476                 tprintf("drops=%u, ", dq.drops);
 477                 tprintf("reads=%u, ", dq.reads);
 478                 tprintf("writes=%u, ", dq.writes);
 479                 tprintf("cache_hits=%u, ", dq.cache_hits);
 480                 tprintf("allocated_dquots=%u, ", dq.allocated_dquots);
 481                 tprintf("free_dquots=%u, ", dq.free_dquots);
 482                 tprintf("syncs=%u}", dq.syncs);
 483                 break;
 484         }
 485         case Q_V2_GETSTATS:
 486         {
 487                 struct v2_dqstats dq;
 488
 489                 if (entering(tcp)) {
 490                         tprints(", ");
 491
 492                         return 0;
 493                 }
 494
 495                 if (umove_or_printaddr(tcp, data, &dq))
 496                         break;
 497                 tprintf("{lookups=%u, ", dq.lookups);
 498                 tprintf("drops=%u, ", dq.drops);
 499                 tprintf("reads=%u, ", dq.reads);
 500                 tprintf("writes=%u, ", dq.writes);
 501                 tprintf("cache_hits=%u, ", dq.cache_hits);
 502                 tprintf("allocated_dquots=%u, ", dq.allocated_dquots);
 503                 tprintf("free_dquots=%u, ", dq.free_dquots);
 504                 tprintf("syncs=%u, ", dq.syncs);
 505                 tprintf("version=%u}", dq.version);
 506                 break;
 507         }
 508         case Q_XGETQSTAT:
 509         {
 510                 struct xfs_dqstats dq;
 511
 512                 if (entering(tcp)) {
 513                         tprints(", ");
 514
 515                         return 0;
 516                 }
 517
 518                 if (umove_or_printaddr(tcp, data, &dq))
 519                         break;
 520                 tprintf("{qs_version=%d, ", dq.qs_version);
 521                 if (abbrev(tcp)) {
 522                         tprints("...}");
 523                         break;
 524                 }
 525                 tprints("qs_flags=");
 526                 printflags(xfs_quota_flags,
 527                            dq.qs_flags, "XFS_QUOTA_???");
 528                 tprintf(", qs_incoredqs=%u, ", dq.qs_incoredqs);
 529                 tprints("qs_uquota={");
 530                 tprintf("qfs_ino=%" PRIu64 ", ", dq.qs_uquota.qfs_ino);
 531                 tprintf("qfs_nblks=%" PRIu64 ", ", dq.qs_uquota.qfs_nblks);
 532                 tprintf("qfs_nextents=%u}, ", dq.qs_uquota.qfs_nextents);
 533                 tprints("qs_gquota={");
 534                 tprintf("qfs_ino=%" PRIu64 ", ", dq.qs_gquota.qfs_ino);
 535                 tprintf("qfs_nblks=%" PRIu64 ", ", dq.qs_gquota.qfs_nblks);
 536                 tprintf("qfs_nextents=%u}, ", dq.qs_gquota.qfs_nextents);
 537                 tprintf("qs_btimelimit=%d, ", dq.qs_btimelimit);
 538                 tprintf("qs_itimelimit=%d, ", dq.qs_itimelimit);
 539                 tprintf("qs_rtbtimelimit=%d, ", dq.qs_rtbtimelimit);
 540                 tprintf("qs_bwarnlimit=%u, ", dq.qs_bwarnlimit);
 541                 tprintf("qs_iwarnlimit=%u}", dq.qs_iwarnlimit);
 542                 break;
 543         }
 544         case Q_XGETQSTATV:
 545         {
 546                 struct fs_quota_statv dq;
 547
 548                 if (entering(tcp)) {
 549                         tprints(", ");
 550
 551                         return 0;
 552                 }
 553
 554                 if (umove_or_printaddr(tcp, data, &dq))
 555                         break;
 556                 tprintf("{qs_version=%d, ", dq.qs_version);
 557                 if (abbrev(tcp)) {
 558                         tprints("...}");
 559                         break;
 560                 }
 561                 tprints("qs_flags=");
 562                 printflags(xfs_quota_flags,
 563                            dq.qs_flags, "XFS_QUOTA_???");
 564                 tprintf(", qs_incoredqs=%u, ", dq.qs_incoredqs);
 565                 tprints("qs_uquota={");
 566                 tprintf("qfs_ino=%" PRIu64 ", ", dq.qs_uquota.qfs_ino);
 567                 tprintf("qfs_nblks=%" PRIu64 ", ", dq.qs_uquota.qfs_nblks);
 568                 tprintf("qfs_nextents=%u}, ", dq.qs_uquota.qfs_nextents);
 569                 tprints("qs_gquota={");
 570                 tprintf("qfs_ino=%" PRIu64 ", ", dq.qs_gquota.qfs_ino);
 571                 tprintf("qfs_nblks=%" PRIu64 ", ", dq.qs_gquota.qfs_nblks);
 572                 tprintf("qfs_nextents=%u}, ", dq.qs_gquota.qfs_nextents);
 573                 tprints("qs_pquota={");
 574                 tprintf("qfs_ino=%" PRIu64 ", ", dq.qs_pquota.qfs_ino);
 575                 tprintf("qfs_nblks=%" PRIu64 ", ", dq.qs_pquota.qfs_nblks);
 576                 tprintf("qfs_nextents=%u}, ", dq.qs_pquota.qfs_nextents);
 577                 tprintf("qs_btimelimit=%d, ", dq.qs_btimelimit);
 578                 tprintf("qs_itimelimit=%d, ", dq.qs_itimelimit);
 579                 tprintf("qs_rtbtimelimit=%d, ", dq.qs_rtbtimelimit);
 580                 tprintf("qs_bwarnlimit=%u, ", dq.qs_bwarnlimit);
 581                 tprintf("qs_iwarnlimit=%u}", dq.qs_iwarnlimit);
 582                 break;
 583         }
 584         case Q_XQUOTAON:
 585         case Q_XQUOTAOFF:
 586         {
 587                 uint32_t flag;
 588
 589                 tprints(", ");
 590
 591                 if (umove_or_printaddr(tcp, data, &flag))
 592                         break;
 593                 tprints("[");
 594                 printflags(xfs_quota_flags, flag, "XFS_QUOTA_???");
 595                 tprints("]");
 596                 break;
 597         }
 598         case Q_XQUOTARM:
 599         {
 600                 uint32_t flag;
 601
 602                 tprints(", ");
 603
 604                 if (umove_or_printaddr(tcp, data, &flag))
 605                         break;
 606                 tprints("[");
 607                 printflags(xfs_dqblk_flags, flag, "XFS_???_QUOTA");
 608                 tprints("]");
 609                 break;
 610         }
 611         default:
 612                 printuid(", ", id);
 613                 tprints(", ");
 614                 printaddr(data);
 615                 break;
 616         }
 617         return RVAL_DECODED;
 618 }
 619
 620 SYS_FUNC(quotactl)
 621 {
 622         /*
 623          * The Linux kernel only looks at the low 32 bits of command and id
 624          * arguments, but on some 64-bit architectures (s390x) this word
 625          * will have been sign-extended when we see it.  The high 1 bits
 626          * don't mean anything, so don't confuse the output with them.
 627          */
 628         uint32_t qcmd = tcp->u_arg[0];
 629         uint32_t cmd = QCMD_CMD(qcmd);
 630         uint32_t type = QCMD_TYPE(qcmd);
 631         uint32_t id = tcp->u_arg[2];
 632
 633         if (entering(tcp)) {
 634                 tprints("QCMD(");
 635                 printxval(quotacmds, cmd, "Q_???");
 636                 tprints(", ");
 637                 printxval(quotatypes, type, "???QUOTA");
 638                 tprints("), ");
 639                 printpath(tcp, tcp->u_arg[1]);
 640                 switch (cmd) {
 641                         case Q_QUOTAON:
 642                         case Q_V1_QUOTAON:
 643                                 tprints(", ");
 644                                 printxval(quota_formats, id, "QFMT_VFS_???");
 645                                 tprints(", ");
 646                                 printpath(tcp, tcp->u_arg[3]);
 647                                 return RVAL_DECODED;
 648                 }
 649         }
 650         return decode_cmd_data(tcp, id, cmd, tcp->u_arg[3]);
 651 }