1 /* 2 * Copyright (c) 2012 Mike Frysinger <vapier (at) gentoo.org> 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. The name of the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include "defs.h" 28 29 #include <linux/ioctl.h> 30 31 /* The mtd api changes quickly, so we have to keep a local copy */ 32 #include <linux/version.h> 33 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0) 34 # include "mtd-abi.h" 35 #else 36 # include <mtd/mtd-abi.h> 37 #endif 38 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0) 39 # include "ubi-user.h" 40 #else 41 # include <mtd/ubi-user.h> 42 #endif 43 44 #include "xlat/mtd_mode_options.h" 45 #include "xlat/mtd_file_mode_options.h" 46 #include "xlat/mtd_type_options.h" 47 #include "xlat/mtd_flags_options.h" 48 #include "xlat/mtd_otp_options.h" 49 #include "xlat/mtd_nandecc_options.h" 50 51 int 52 mtd_ioctl(struct tcb *tcp, const unsigned int code, const long arg) 53 { 54 if (!verbose(tcp)) 55 return RVAL_DECODED; 56 57 switch (code) { 58 case MEMERASE: 59 case MEMLOCK: 60 case MEMUNLOCK: 61 case MEMISLOCKED: { 62 struct erase_info_user einfo; 63 64 tprints(", "); 65 if (umove_or_printaddr(tcp, arg, &einfo)) 66 break; 67 68 tprintf("{start=%#" PRIx32 ", length=%#" PRIx32 "}", 69 einfo.start, einfo.length); 70 break; 71 } 72 73 case MEMERASE64: { 74 struct erase_info_user64 einfo64; 75 76 tprints(", "); 77 if (umove_or_printaddr(tcp, arg, &einfo64)) 78 break; 79 80 tprintf("{start=%#" PRIx64 ", length=%#" PRIx64 "}", 81 (uint64_t) einfo64.start, (uint64_t) einfo64.length); 82 break; 83 } 84 85 case MEMWRITEOOB: 86 case MEMREADOOB: { 87 struct mtd_oob_buf mbuf; 88 89 tprints(", "); 90 if (umove_or_printaddr(tcp, arg, &mbuf)) 91 break; 92 93 tprintf("{start=%#" PRIx32 ", length=%#" PRIx32 ", ptr=...}", 94 mbuf.start, mbuf.length); 95 break; 96 } 97 98 case MEMWRITEOOB64: 99 case MEMREADOOB64: { 100 struct mtd_oob_buf64 mbuf64; 101 102 tprints(", "); 103 if (umove_or_printaddr(tcp, arg, &mbuf64)) 104 break; 105 106 tprintf("{start=%#" PRIx64 ", length=%#" PRIx64 ", ptr=...}", 107 (uint64_t) mbuf64.start, (uint64_t) mbuf64.length); 108 break; 109 } 110 111 case MEMGETREGIONINFO: { 112 struct region_info_user rinfo; 113 114 if (entering(tcp)) { 115 tprints(", "); 116 if (umove_or_printaddr(tcp, arg, &rinfo)) 117 break; 118 tprintf("{regionindex=%#x", rinfo.regionindex); 119 return 1; 120 } else { 121 if (syserror(tcp)) { 122 tprints("}"); 123 break; 124 } 125 if (umove(tcp, arg, &rinfo) < 0) { 126 tprints(", ???}"); 127 break; 128 } 129 tprintf(", offset=%#x, erasesize=%#x, numblocks=%#x}", 130 rinfo.offset, rinfo.erasesize, rinfo.numblocks); 131 break; 132 } 133 } 134 135 case OTPLOCK: { 136 struct otp_info oinfo; 137 138 tprints(", "); 139 if (umove_or_printaddr(tcp, arg, &oinfo)) 140 break; 141 142 tprintf("{start=%#" PRIx32 ", length=%#" PRIx32 ", locked=%" PRIu32 "}", 143 oinfo.start, oinfo.length, oinfo.locked); 144 break; 145 } 146 147 case MEMWRITE: { 148 struct mtd_write_req mreq; 149 150 tprints(", "); 151 if (umove_or_printaddr(tcp, arg, &mreq)) 152 break; 153 154 tprintf("{start=%#" PRIx64 ", len=%#" PRIx64, 155 (uint64_t) mreq.start, (uint64_t) mreq.len); 156 tprintf(", ooblen=%#" PRIx64 ", usr_data=%#" PRIx64, 157 (uint64_t) mreq.ooblen, (uint64_t) mreq.usr_data); 158 tprintf(", usr_oob=%#" PRIx64 ", mode=", 159 (uint64_t) mreq.usr_oob); 160 printxval(mtd_mode_options, mreq.mode, "MTD_OPS_???"); 161 tprints(", padding=...}"); 162 break; 163 } 164 165 case OTPSELECT: { 166 unsigned int i; 167 168 tprints(", "); 169 if (umove_or_printaddr(tcp, arg, &i)) 170 break; 171 172 tprints("["); 173 printxval(mtd_otp_options, i, "MTD_OTP_???"); 174 tprints("]"); 175 break; 176 } 177 178 case MTDFILEMODE: 179 tprints(", "); 180 printxval(mtd_file_mode_options, arg, "MTD_FILE_MODE_???"); 181 break; 182 183 case MEMGETBADBLOCK: 184 case MEMSETBADBLOCK: 185 tprints(", "); 186 printnum_int64(tcp, arg, "%" PRIu64); 187 break; 188 189 case MEMGETINFO: { 190 struct mtd_info_user minfo; 191 192 if (entering(tcp)) 193 return 0; 194 195 tprints(", "); 196 if (umove_or_printaddr(tcp, arg, &minfo)) 197 break; 198 199 tprints("{type="); 200 printxval(mtd_type_options, minfo.type, "MTD_???"); 201 tprints(", flags="); 202 printflags(mtd_flags_options, minfo.flags, "MTD_???"); 203 tprintf(", size=%#" PRIx32 ", erasesize=%#" PRIx32, 204 minfo.size, minfo.erasesize); 205 tprintf(", writesize=%#" PRIx32 ", oobsize=%#" PRIx32, 206 minfo.writesize, minfo.oobsize); 207 tprintf(", padding=%#" PRIx64 "}", 208 (uint64_t) minfo.padding); 209 break; 210 } 211 212 case MEMGETOOBSEL: { 213 struct nand_oobinfo ninfo; 214 unsigned int i; 215 216 if (entering(tcp)) 217 return 0; 218 219 tprints(", "); 220 if (umove_or_printaddr(tcp, arg, &ninfo)) 221 break; 222 223 tprints("{useecc="); 224 printxval(mtd_nandecc_options, ninfo.useecc, "MTD_NANDECC_???"); 225 tprintf(", eccbytes=%#" PRIx32, ninfo.eccbytes); 226 227 tprints(", oobfree={"); 228 for (i = 0; i < ARRAY_SIZE(ninfo.oobfree); ++i) { 229 unsigned int j; 230 231 if (i) 232 tprints("}, "); 233 tprints("{"); 234 for (j = 0; j < ARRAY_SIZE(ninfo.oobfree[0]); ++j) { 235 if (j) 236 tprints(", "); 237 tprintf("%#" PRIx32, ninfo.oobfree[i][j]); 238 } 239 } 240 241 tprints("}}, eccpos={"); 242 for (i = 0; i < ARRAY_SIZE(ninfo.eccpos); ++i) { 243 if (i) 244 tprints(", "); 245 tprintf("%#" PRIx32, ninfo.eccpos[i]); 246 } 247 248 tprints("}"); 249 break; 250 } 251 252 case OTPGETREGIONINFO: { 253 struct otp_info oinfo; 254 255 if (entering(tcp)) 256 return 0; 257 258 tprints(", "); 259 if (umove_or_printaddr(tcp, arg, &oinfo)) 260 break; 261 262 tprintf("{start=%#" PRIx32 ", length=%#" PRIx32 ", locked=%" PRIu32 "}", 263 oinfo.start, oinfo.length, oinfo.locked); 264 break; 265 } 266 267 case ECCGETLAYOUT: { 268 struct nand_ecclayout_user nlay; 269 unsigned int i; 270 271 if (entering(tcp)) 272 return 0; 273 274 tprints(", "); 275 if (umove_or_printaddr(tcp, arg, &nlay)) 276 break; 277 278 tprintf("{eccbytes=%#" PRIx32 ", eccpos={", nlay.eccbytes); 279 for (i = 0; i < ARRAY_SIZE(nlay.eccpos); ++i) { 280 if (i) 281 tprints(", "); 282 tprintf("%#" PRIx32, nlay.eccpos[i]); 283 } 284 tprintf("}, oobavail=%#" PRIx32 ", oobfree={", nlay.oobavail); 285 for (i = 0; i < ARRAY_SIZE(nlay.oobfree); ++i) { 286 if (i) 287 tprints(", "); 288 tprintf("{offset=%#" PRIx32 ", length=%#" PRIx32 "}", 289 nlay.oobfree[i].offset, nlay.oobfree[i].length); 290 } 291 tprints("}"); 292 break; 293 } 294 295 case ECCGETSTATS: { 296 struct mtd_ecc_stats estat; 297 298 if (entering(tcp)) 299 return 0; 300 301 tprints(", "); 302 if (umove_or_printaddr(tcp, arg, &estat)) 303 break; 304 305 tprintf("{corrected=%#" PRIx32 ", failed=%#" PRIx32, 306 estat.corrected, estat.failed); 307 tprintf(", badblocks=%#" PRIx32 ", bbtblocks=%#" PRIx32 "}", 308 estat.badblocks, estat.bbtblocks); 309 break; 310 } 311 312 case OTPGETREGIONCOUNT: 313 if (entering(tcp)) 314 return 0; 315 316 tprints(", "); 317 printnum_int(tcp, arg, "%u"); 318 break; 319 320 case MEMGETREGIONCOUNT: 321 if (entering(tcp)) 322 return 0; 323 324 tprints(", "); 325 printnum_int(tcp, arg, "%d"); 326 break; 327 328 default: 329 return RVAL_DECODED; 330 } 331 332 return RVAL_DECODED | 1; 333 } 334 335 #include "xlat/ubi_volume_types.h" 336 #include "xlat/ubi_volume_props.h" 337 338 int 339 ubi_ioctl(struct tcb *tcp, const unsigned int code, const long arg) 340 { 341 if (!verbose(tcp)) 342 return RVAL_DECODED; 343 344 switch (code) { 345 case UBI_IOCMKVOL: 346 if (entering(tcp)) { 347 struct ubi_mkvol_req mkvol; 348 349 tprints(", "); 350 if (umove_or_printaddr(tcp, arg, &mkvol)) 351 break; 352 353 tprintf("{vol_id=%" PRIi32 ", alignment=%" PRIi32 354 ", bytes=%" PRIi64 ", vol_type=", mkvol.vol_id, 355 mkvol.alignment, (int64_t)mkvol.bytes); 356 printxval(ubi_volume_types, mkvol.vol_type, "UBI_???_VOLUME"); 357 tprintf(", name_len=%" PRIi16 ", name=", mkvol.name_len); 358 if (print_quoted_string(mkvol.name, 359 CLAMP(mkvol.name_len, 0, UBI_MAX_VOLUME_NAME), 360 QUOTE_0_TERMINATED) > 0) { 361 tprints("..."); 362 } 363 tprints("}"); 364 return 1; 365 } 366 if (!syserror(tcp)) { 367 tprints(" => "); 368 printnum_int(tcp, arg, "%d"); 369 } 370 break; 371 372 case UBI_IOCRSVOL: { 373 struct ubi_rsvol_req rsvol; 374 375 tprints(", "); 376 if (umove_or_printaddr(tcp, arg, &rsvol)) 377 break; 378 379 tprintf("{vol_id=%" PRIi32 ", bytes=%" PRIi64 "}", 380 rsvol.vol_id, (int64_t)rsvol.bytes); 381 break; 382 } 383 384 case UBI_IOCRNVOL: { 385 struct ubi_rnvol_req rnvol; 386 int c; 387 388 tprints(", "); 389 if (umove_or_printaddr(tcp, arg, &rnvol)) 390 break; 391 392 tprintf("{count=%" PRIi32 ", ents=[", rnvol.count); 393 for (c = 0; c < CLAMP(rnvol.count, 0, UBI_MAX_RNVOL); ++c) { 394 if (c) 395 tprints(", "); 396 tprintf("{vol_id=%" PRIi32 ", name_len=%" PRIi16 397 ", name=", rnvol.ents[c].vol_id, 398 rnvol.ents[c].name_len); 399 if (print_quoted_string(rnvol.ents[c].name, 400 CLAMP(rnvol.ents[c].name_len, 0, UBI_MAX_VOLUME_NAME), 401 QUOTE_0_TERMINATED) > 0) { 402 tprints("..."); 403 } 404 tprints("}"); 405 } 406 tprints("]}"); 407 break; 408 } 409 410 case UBI_IOCEBCH: { 411 struct ubi_leb_change_req leb; 412 413 tprints(", "); 414 if (umove_or_printaddr(tcp, arg, &leb)) 415 break; 416 417 tprintf("{lnum=%d, bytes=%d}", leb.lnum, leb.bytes); 418 break; 419 } 420 421 case UBI_IOCATT: 422 if (entering(tcp)) { 423 struct ubi_attach_req attach; 424 425 tprints(", "); 426 if (umove_or_printaddr(tcp, arg, &attach)) 427 break; 428 429 tprintf("{ubi_num=%" PRIi32 ", mtd_num=%" PRIi32 430 ", vid_hdr_offset=%" PRIi32 431 ", max_beb_per1024=%" PRIi16 "}", 432 attach.ubi_num, attach.mtd_num, 433 attach.vid_hdr_offset, attach.max_beb_per1024); 434 return 1; 435 } 436 if (!syserror(tcp)) { 437 tprints(" => "); 438 printnum_int(tcp, arg, "%d"); 439 } 440 break; 441 442 case UBI_IOCEBMAP: { 443 struct ubi_map_req map; 444 445 tprints(", "); 446 if (umove_or_printaddr(tcp, arg, &map)) 447 break; 448 449 tprintf("{lnum=%" PRIi32 ", dtype=%" PRIi8 "}", 450 map.lnum, map.dtype); 451 break; 452 } 453 454 case UBI_IOCSETVOLPROP: { 455 struct ubi_set_vol_prop_req prop; 456 457 tprints(", "); 458 if (umove_or_printaddr(tcp, arg, &prop)) 459 break; 460 461 tprints("{property="); 462 printxval(ubi_volume_props, prop.property, "UBI_VOL_PROP_???"); 463 tprintf(", value=%#" PRIx64 "}", (uint64_t)prop.value); 464 break; 465 } 466 467 468 case UBI_IOCVOLUP: 469 tprints(", "); 470 printnum_int64(tcp, arg, "%" PRIi64); 471 break; 472 473 case UBI_IOCDET: 474 case UBI_IOCEBER: 475 case UBI_IOCEBISMAP: 476 case UBI_IOCEBUNMAP: 477 case UBI_IOCRMVOL: 478 tprints(", "); 479 printnum_int(tcp, arg, "%d"); 480 break; 481 482 #ifdef UBI_IOCVOLCRBLK 483 case UBI_IOCVOLCRBLK: 484 #endif 485 #ifdef UBI_IOCVOLRMBLK 486 case UBI_IOCVOLRMBLK: 487 #endif 488 /* no arguments */ 489 break; 490 491 default: 492 return RVAL_DECODED; 493 } 494 495 return RVAL_DECODED | 1; 496 } 497
