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