1/* 2 * Check decoding of quotactl xfs subcommands. 3 * 4 * Copyright (c) 2016 Eugene Syromyatnikov <evgsyr@gmail.com> 5 * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org> 6 * Copyright (c) 2016-2017 The strace developers. 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 "tests.h" 33 34#include <asm/unistd.h> 35 36#if defined(__NR_quotactl) && \ 37 (defined(HAVE_LINUX_QUOTA_H) || defined(HAVE_SYS_QUOTA_H)) && \ 38 defined(HAVE_LINUX_DQBLK_XFS_H) 39 40# include <stdio.h> 41# include <string.h> 42# include <unistd.h> 43 44# include <linux/dqblk_xfs.h> 45 46# include "quotactl.h" 47 48# ifndef Q_GETNEXTQUOTA 49# define Q_XGETNEXTQUOTA XQM_CMD(0x9) 50# endif /* !Q_GETNEXTQUOTA */ 51 52# ifndef Q_XGETQSTATV 53 54# define Q_XGETQSTATV XQM_CMD(8) 55# define FS_QSTATV_VERSION1 1 56 57struct fs_qfilestatv { 58 uint64_t qfs_ino; /* inode number */ 59 uint64_t qfs_nblks; /* number of BBs 512-byte-blks */ 60 uint32_t qfs_nextents; /* number of extents */ 61 uint32_t qfs_pad; /* pad for 8-byte alignment */ 62}; 63 64struct fs_quota_statv { 65 int8_t qs_version; /* version for future changes */ 66 uint8_t qs_pad1; /* pad for 16bit alignment */ 67 uint16_t qs_flags; /* XFS_QUOTA_.* flags */ 68 uint32_t qs_incoredqs; /* number of dquots incore */ 69 struct fs_qfilestatv qs_uquota; /* user quota information */ 70 struct fs_qfilestatv qs_gquota; /* group quota information */ 71 struct fs_qfilestatv qs_pquota; /* project quota information */ 72 int32_t qs_btimelimit; /* limit for blks timer */ 73 int32_t qs_itimelimit; /* limit for inodes timer */ 74 int32_t qs_rtbtimelimit; /* limit for rt blks timer */ 75 uint16_t qs_bwarnlimit; /* limit for num warnings */ 76 uint16_t qs_iwarnlimit; /* limit for num warnings */ 77 uint64_t qs_pad2[8]; /* for future proofing */ 78}; 79 80# endif /* !Q_XGETQSTATV */ 81 82# include "xlat.h" 83# include "xlat/xfs_dqblk_flags.h" 84# if VERBOSE 85# include "xlat/xfs_quota_flags.h" 86# endif 87 88 89void 90print_xdisk_quota(int rc, void *ptr, void *arg) 91{ 92 struct fs_disk_quota *dq = ptr; 93 long out_arg = (long) arg; 94 95 if (((rc != 0) && out_arg) || (out_arg > 1)) { 96 printf("%p", dq); 97 return; 98 } 99 100 PRINT_FIELD_D("{", *dq, d_version); 101 printf(", d_flags="); 102 printflags(xfs_dqblk_flags, (uint8_t) dq->d_flags, "XFS_???_QUOTA"); 103 104 PRINT_FIELD_X(", ", *dq, d_fieldmask); 105 PRINT_FIELD_U(", ", *dq, d_id); 106 PRINT_FIELD_U(", ", *dq, d_blk_hardlimit); 107 PRINT_FIELD_U(", ", *dq, d_blk_softlimit); 108 PRINT_FIELD_U(", ", *dq, d_ino_hardlimit); 109 PRINT_FIELD_U(", ", *dq, d_ino_softlimit); 110 PRINT_FIELD_U(", ", *dq, d_bcount); 111 PRINT_FIELD_U(", ", *dq, d_icount); 112 113# if VERBOSE 114 PRINT_FIELD_D(", ", *dq, d_itimer); 115 PRINT_FIELD_D(", ", *dq, d_btimer); 116 PRINT_FIELD_U(", ", *dq, d_iwarns); 117 PRINT_FIELD_U(", ", *dq, d_bwarns); 118 PRINT_FIELD_U(", ", *dq, d_rtb_hardlimit); 119 PRINT_FIELD_U(", ", *dq, d_rtb_softlimit); 120 PRINT_FIELD_U(", ", *dq, d_rtbcount); 121 PRINT_FIELD_D(", ", *dq, d_rtbtimer); 122 PRINT_FIELD_U(", ", *dq, d_rtbwarns); 123# else 124 printf(", ..."); 125# endif /* !VERBOSE */ 126 printf("}"); 127} 128 129void 130print_xquota_stat(int rc, void *ptr, void *arg) 131{ 132 struct fs_quota_stat *qs = ptr; 133 long out_arg = (long) arg; 134 135 if (((rc != 0) && out_arg) || (out_arg > 1)) { 136 printf("%p", qs); 137 return; 138 } 139 140 PRINT_FIELD_D("{", *qs, qs_version); 141 142# if VERBOSE 143 printf(", qs_flags="); 144 printflags(xfs_quota_flags, qs->qs_flags, "XFS_QUOTA_???"); 145 PRINT_FIELD_U(", qs_uquota={", qs->qs_uquota, qfs_ino); 146 PRINT_FIELD_U(", ", qs->qs_uquota, qfs_nblks); 147 PRINT_FIELD_U(", ", qs->qs_uquota, qfs_nextents); 148 PRINT_FIELD_U("}, qs_gquota={", qs->qs_gquota, qfs_ino); 149 PRINT_FIELD_U(", ", qs->qs_gquota, qfs_nblks); 150 PRINT_FIELD_U(", ", qs->qs_gquota, qfs_nextents); 151 PRINT_FIELD_U("}, ", *qs, qs_incoredqs); 152 PRINT_FIELD_D(", ", *qs, qs_btimelimit); 153 PRINT_FIELD_D(", ", *qs, qs_itimelimit); 154 PRINT_FIELD_D(", ", *qs, qs_rtbtimelimit); 155 PRINT_FIELD_U(", ", *qs, qs_bwarnlimit); 156 PRINT_FIELD_U(", ", *qs, qs_iwarnlimit); 157# else 158 printf(", ..."); 159# endif /* !VERBOSE */ 160 printf("}"); 161} 162 163void 164print_xquota_statv(int rc, void *ptr, void *arg) 165{ 166 struct fs_quota_statv *qs = ptr; 167 long out_arg = (long) arg; 168 169 if (((rc != 0) && out_arg) || (out_arg > 1)) { 170 printf("%p", qs); 171 return; 172 } 173 174 PRINT_FIELD_D("{", *qs, qs_version); 175 176# if VERBOSE 177 printf(", qs_flags="); 178 printflags(xfs_quota_flags, qs->qs_flags, "XFS_QUOTA_???"); 179 PRINT_FIELD_U(", ", *qs, qs_incoredqs); 180 PRINT_FIELD_U(", qs_uquota={", qs->qs_uquota, qfs_ino); 181 PRINT_FIELD_U(", ", qs->qs_uquota, qfs_nblks); 182 PRINT_FIELD_U(", ", qs->qs_uquota, qfs_nextents); 183 PRINT_FIELD_U("}, qs_gquota={", qs->qs_gquota, qfs_ino); 184 PRINT_FIELD_U(", ", qs->qs_gquota, qfs_nblks); 185 PRINT_FIELD_U(", ", qs->qs_gquota, qfs_nextents); 186 PRINT_FIELD_U("}, qs_pquota={", qs->qs_pquota, qfs_ino); 187 PRINT_FIELD_U(", ", qs->qs_pquota, qfs_nblks); 188 PRINT_FIELD_U(", ", qs->qs_pquota, qfs_nextents); 189 PRINT_FIELD_D("}, ", *qs, qs_btimelimit); 190 PRINT_FIELD_D(", ", *qs, qs_itimelimit); 191 PRINT_FIELD_D(", ", *qs, qs_rtbtimelimit); 192 PRINT_FIELD_U(", ", *qs, qs_bwarnlimit); 193 PRINT_FIELD_U(", ", *qs, qs_iwarnlimit); 194# else 195 printf(", ..."); 196# endif /* !VERBOSE */ 197 printf("}"); 198} 199 200int 201main(void) 202{ 203 char *bogus_special = (char *) tail_alloc(1) + 1; 204 void *bogus_addr = (char *) tail_alloc(1) + 1; 205 206 char bogus_special_str[sizeof(void *) * 2 + sizeof("0x")]; 207 char bogus_addr_str[sizeof(void *) * 2 + sizeof("0x")]; 208 char unterminated_str[sizeof(void *) * 2 + sizeof("0x")]; 209 210 long rc; 211 TAIL_ALLOC_OBJECT_CONST_PTR(struct fs_disk_quota, xdq); 212 TAIL_ALLOC_OBJECT_CONST_PTR(struct fs_quota_stat, xqstat); 213 TAIL_ALLOC_OBJECT_CONST_PTR(struct fs_quota_statv, xqstatv); 214 TAIL_ALLOC_OBJECT_CONST_PTR(uint32_t, flags); 215 char *unterminated = tail_memdup(unterminated_data, 216 sizeof(unterminated_data)); 217 218 snprintf(bogus_special_str, sizeof(bogus_special_str), "%p", 219 bogus_special); 220 snprintf(bogus_addr_str, sizeof(bogus_addr_str), "%p", 221 bogus_addr); 222 snprintf(unterminated_str, sizeof(unterminated_str), "%p", 223 unterminated); 224 225 226 /* Q_XQUOTAON */ 227 228 *flags = 0xdeadbeef; 229 230 check_quota(CQF_ID_SKIP | CQF_ADDR_STR, 231 ARG_STR(QCMD(Q_XQUOTAON, USRQUOTA)), 232 ARG_STR("/dev/bogus/"), flags, 233 "[XFS_QUOTA_UDQ_ACCT|XFS_QUOTA_UDQ_ENFD" 234 "|XFS_QUOTA_GDQ_ACCT|XFS_QUOTA_GDQ_ENFD" 235 "|XFS_QUOTA_PDQ_ENFD|0xdeadbec0]"); 236 237 rc = syscall(__NR_quotactl, QCMD(Q_XQUOTAON, 0xfacefeed), bogus_dev, 238 bogus_id, bogus_addr); 239 printf("quotactl(QCMD(Q_XQUOTAON, %#x /* ???QUOTA */)" 240 ", %s, %p) = %s\n", 241 QCMD_TYPE(QCMD(Q_XQUOTAON, 0xfacefeed)), 242 bogus_dev_str, bogus_addr, sprintrc(rc)); 243 244 245 /* Q_XQUOTAOFF */ 246 247 check_quota(CQF_ID_SKIP | CQF_ADDR_STR, 248 ARG_STR(QCMD(Q_XQUOTAOFF, USRQUOTA)), 249 bogus_special, bogus_special_str, 250 bogus_addr, bogus_addr_str); 251 check_quota(CQF_ID_SKIP | CQF_ADDR_STR, 252 ARG_STR(QCMD(Q_XQUOTAOFF, GRPQUOTA)), 253 ARG_STR("/dev/bogus/"), 254 ARG_STR(NULL)); 255 check_quota(CQF_ID_SKIP | CQF_ADDR_STR, 256 QCMD(Q_XQUOTAOFF, 3), 257 "QCMD(Q_XQUOTAOFF, 0x3 /* ???QUOTA */)", 258 ARG_STR("/dev/bogus/"), flags, 259 "[XFS_QUOTA_UDQ_ACCT|XFS_QUOTA_UDQ_ENFD" 260 "|XFS_QUOTA_GDQ_ACCT|XFS_QUOTA_GDQ_ENFD" 261 "|XFS_QUOTA_PDQ_ENFD|0xdeadbec0]"); 262 263 264 /* Q_XGETQUOTA */ 265 266 /* Trying our best to get successful result */ 267 check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_GETQUOTA, USRQUOTA)), 268 ARG_STR("/dev/sda1"), getuid(), xdq, print_xdisk_quota, 269 (intptr_t) 1); 270 271 check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_GETQUOTA, GRPQUOTA)), 272 ARG_STR(NULL), -1, xdq, print_xdisk_quota, (intptr_t) 2); 273 274 275 /* Q_XGETNEXTQUOTA */ 276 277 check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_XGETNEXTQUOTA, USRQUOTA)), 278 ARG_STR("/dev/sda1"), 0, xdq, print_xdisk_quota, 279 (intptr_t) 1); 280 281 282 /* Q_XSETQLIM */ 283 284 check_quota(CQF_NONE, ARG_STR(QCMD(Q_XSETQLIM, PRJQUOTA)), 285 bogus_special, bogus_special_str, 0, bogus_addr); 286 287 fill_memory_ex(xdq, sizeof(*xdq), 0x8e, 0x80); 288 289 check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_XSETQLIM, PRJQUOTA)), 290 bogus_dev, bogus_dev_str, 3141592653U, 291 xdq, print_xdisk_quota, (intptr_t) 0); 292 293 294 /* Q_XGETQSTAT */ 295 296 check_quota(CQF_ID_SKIP | CQF_ADDR_CB, 297 ARG_STR(QCMD(Q_XGETQSTAT, USRQUOTA)), 298 ARG_STR("/dev/sda1"), xqstat, print_xquota_stat, (intptr_t) 1); 299 300 check_quota(CQF_ID_SKIP | CQF_ADDR_CB, 301 ARG_STR(QCMD(Q_XGETQSTATV, PRJQUOTA)), 302 unterminated, unterminated_str, 303 xqstat + 1, print_xquota_stat, (intptr_t) 2); 304 305 306 /* Q_XGETQSTATV */ 307 308 check_quota(CQF_ID_SKIP | CQF_ADDR_CB, 309 ARG_STR(QCMD(Q_XGETQSTAT, USRQUOTA)), 310 ARG_STR("/dev/sda1"), xqstatv, print_xquota_statv, 1); 311 312 check_quota(CQF_ID_SKIP | CQF_ADDR_CB, 313 ARG_STR(QCMD(Q_XGETQSTATV, GRPQUOTA)), 314 ARG_STR(NULL), xqstatv, print_xquota_statv, (intptr_t) 2); 315 316 317 /* Q_XQUOTARM */ 318 319 check_quota(CQF_ID_SKIP | CQF_ADDR_STR, 320 ARG_STR(QCMD(Q_XQUOTARM, PRJQUOTA)), 321 bogus_special, bogus_special_str, ARG_STR(NULL)); 322 check_quota(CQF_ID_SKIP, 323 ARG_STR(QCMD(Q_XQUOTARM, USRQUOTA)), 324 unterminated, unterminated_str, flags + 1); 325 326 *flags = 0xdeadbeef; 327 check_quota(CQF_ID_SKIP | CQF_ADDR_STR, 328 ARG_STR(QCMD(Q_XQUOTARM, GRPQUOTA)), 329 ARG_STR(NULL), flags, 330 "[XFS_USER_QUOTA|XFS_PROJ_QUOTA" 331 "|XFS_GROUP_QUOTA|0xdeadbee8]"); 332 333 334 /* Q_XQUOTASYNC */ 335 336 check_quota(CQF_ID_SKIP | CQF_ADDR_SKIP, 337 ARG_STR(QCMD(Q_XQUOTASYNC, USRQUOTA)), 338 bogus_special, bogus_special_str); 339 check_quota(CQF_ID_SKIP | CQF_ADDR_SKIP, 340 QCMD(Q_XQUOTASYNC, 0xfff), 341 "QCMD(Q_XQUOTASYNC, 0xff /* ???QUOTA */)", 342 ARG_STR(NULL)); 343 344 puts("+++ exited with 0 +++"); 345 346 return 0; 347} 348 349#else 350 351SKIP_MAIN_UNDEFINED("__NR_quotactl && " 352 "(HAVE_LINUX_QUOTA_H || HAVE_SYS_QUOTA_H) && " 353 "HAVE_LINUX_DQBLK_XFS_H"); 354 355#endif 356