int term_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg) { switch (code) { /* struct termios */ case TCGETS: #ifdef TCGETS2 case TCGETS2: #endif case TIOCGLCKTRMIOS: if (entering(tcp)) return 0; case TCSETS: #ifdef TCSETS2 case TCSETS2: #endif case TCSETSW: #ifdef TCSETSW2 case TCSETSW2: #endif case TCSETSF: #ifdef TCSETSF2 case TCSETSF2: #endif case TIOCSLCKTRMIOS: decode_termios(tcp, arg); break; /* struct termio */ case TCGETA: if (entering(tcp)) return 0; case TCSETA: case TCSETAW: case TCSETAF: decode_termio(tcp, arg); break; /* struct winsize */ case TIOCGWINSZ: if (entering(tcp)) return 0; case TIOCSWINSZ: decode_winsize(tcp, arg); break; /* struct ttysize */ #ifdef TIOCGSIZE case TIOCGSIZE: if (entering(tcp)) return 0; case TIOCSSIZE: decode_ttysize(tcp, arg); break; #endif /* ioctls with a direct decodable arg */ case TCXONC: tprints(", "); printxval64(tcxonc_options, arg, "TC???"); break; case TCFLSH: tprints(", "); printxval64(tcflsh_options, arg, "TC???"); break; case TCSBRK: case TCSBRKP: case TIOCSCTTY: tprintf(", %d", (int) arg); break; /* ioctls with an indirect parameter displayed as modem flags */ case TIOCMGET: if (entering(tcp)) return 0; case TIOCMBIS: case TIOCMBIC: case TIOCMSET: decode_modem_flags(tcp, arg); break; /* ioctls with an indirect parameter displayed in decimal */ case TIOCGPGRP: case TIOCGSID: case TIOCGETD: case TIOCGSOFTCAR: case TIOCGPTN: case FIONREAD: case TIOCOUTQ: #ifdef TIOCGEXCL case TIOCGEXCL: #endif #ifdef TIOCGDEV case TIOCGDEV: #endif if (entering(tcp)) return 0; case TIOCSPGRP: case TIOCSETD: case FIONBIO: case FIOASYNC: case TIOCPKT: case TIOCSSOFTCAR: case TIOCSPTLCK: tprints(", "); printnum_int(tcp, arg, "%d"); break; /* ioctls with an indirect parameter displayed as a char */ case TIOCSTI: tprints(", "); printstrn(tcp, arg, 1); break; /* ioctls with no parameters */ case TIOCSBRK: case TIOCCBRK: case TIOCCONS: case TIOCNOTTY: case TIOCEXCL: case TIOCNXCL: case FIOCLEX: case FIONCLEX: #ifdef TIOCVHANGUP case TIOCVHANGUP: #endif #ifdef TIOCSSERIAL case TIOCSSERIAL: #endif break; /* ioctls which are unknown */ default: return RVAL_DECODED; } return RVAL_IOCTL_DECODED; }
MPERS_PRINTER_DECL(int, btrfs_ioctl, struct tcb *tcp, const unsigned int code, const long arg) { switch (code) { /* Take no arguments; command only. */ case BTRFS_IOC_TRANS_START: case BTRFS_IOC_TRANS_END: case BTRFS_IOC_SYNC: case BTRFS_IOC_SCRUB_CANCEL: case BTRFS_IOC_QUOTA_RESCAN_WAIT: /* * The codes for these ioctls are based on each accepting a * vol_args but none of them actually consume an argument. */ case BTRFS_IOC_DEFRAG: case BTRFS_IOC_BALANCE: break; /* takes a signed int */ case BTRFS_IOC_BALANCE_CTL: tprints(", "); printxval(btrfs_balance_ctl_cmds, arg, "BTRFS_BALANCE_CTL_???"); break; /* returns a 64 */ case BTRFS_IOC_START_SYNC: /* R */ if (entering(tcp)) return 0; /* fall through */ /* takes a u64 */ case BTRFS_IOC_DEFAULT_SUBVOL: /* W */ case BTRFS_IOC_WAIT_SYNC: /* W */ tprints(", "); printnum_int64(tcp, arg, "%" PRIu64); break; /* u64 but describe a flags bitfield; we can make that symbolic */ case BTRFS_IOC_SUBVOL_GETFLAGS: { /* R */ uint64_t flags; if (entering(tcp)) return 0; tprints(", "); if (umove_or_printaddr(tcp, arg, &flags)) break; printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???"); break; } case BTRFS_IOC_SUBVOL_SETFLAGS: { /* W */ uint64_t flags; tprints(", "); if (umove_or_printaddr(tcp, arg, &flags)) break; printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???"); break; } /* More complex types */ case BTRFS_IOC_BALANCE_V2: /* RW */ if (entering(tcp)) { tprints(", "); btrfs_print_balance(tcp, arg, false); return 0; } if (syserror(tcp)) break; tprints(" => "); btrfs_print_balance(tcp, arg, true); break; case BTRFS_IOC_BALANCE_PROGRESS: /* R */ if (entering(tcp)) return 0; tprints(", "); btrfs_print_balance(tcp, arg, true); break; case BTRFS_IOC_DEFRAG_RANGE: { /* W */ struct btrfs_ioctl_defrag_range_args args; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprintf("{start=%" PRIu64 ", len=", (uint64_t)args.start); tprintf("%" PRIu64, (uint64_t) args.len); if (args.len == UINT64_MAX) tprints(" /* UINT64_MAX */"); tprints(", flags="); printflags64(btrfs_defrag_flags, args.flags, "BTRFS_DEFRAG_RANGE_???"); tprintf(", extent_thresh=%u, compress_type=", args.extent_thresh); printxval(btrfs_compress_types, args.compress_type, "BTRFS_COMPRESS_???"); tprints("}"); break; } case BTRFS_IOC_DEV_INFO: { /* RW */ struct btrfs_ioctl_dev_info_args args; char uuid[UUID_STRING_SIZE+1]; int valid; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; tprints("{"); valid = btrfs_unparse_uuid(args.uuid, uuid); if (entering(tcp)) { tprintf("devid=%" PRI__u64, args.devid); if (valid) tprintf(", uuid=%s", uuid); tprints("}"); return 0; } if (valid) tprintf("uuid=%s, ", uuid); tprintf("bytes_used=%" PRI__u64 ", total_bytes=%" PRI__u64 ", path=", args.bytes_used, args.total_bytes); print_quoted_string((const char *)args.path, sizeof(args.path), QUOTE_0_TERMINATED); tprints("}"); break; } case BTRFS_IOC_DEV_REPLACE: { /* RW */ struct_btrfs_ioctl_dev_replace_args args; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; if (entering(tcp)) { tprints("{cmd="); printxval64(btrfs_dev_replace_cmds, args.cmd, "BTRFS_IOCTL_DEV_REPLACE_CMD_???"); if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_START) { const char *str; tprintf(", start={srcdevid=%" PRIu64 ", cont_reading_from_srcdev_mode=%" PRIu64 ", srcdev_name=", (uint64_t) args.start.srcdevid, (uint64_t) args.start.cont_reading_from_srcdev_mode); str = (const char*) args.start.srcdev_name; print_quoted_string(str, sizeof(args.start.srcdev_name), QUOTE_0_TERMINATED); tprints(", tgtdev_name="); str = (const char*) args.start.tgtdev_name; print_quoted_string(str, sizeof(args.start.tgtdev_name), QUOTE_0_TERMINATED); tprints("}"); } tprints("}"); return 0; } tprints("{result="); printxval64(btrfs_dev_replace_results, args.result, "BTRFS_IOCTL_DEV_REPLACE_RESULT_???"); if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS) { char buf[sizeof("HH:MM:SS") + 1]; time_t time; tprints(", "); printxval64(btrfs_dev_replace_state, args.status.replace_state, "BTRFS_IOCTL_DEV_REPLACE_STATE_???"); tprintf(", progress_1000=%" PRIu64 " /* ", (uint64_t) args.status.progress_1000); if (args.status.progress_1000 <= 1000) tprintf("%" PRIu64 ".%.2" PRIu64 "%%", (uint64_t) args.status.progress_1000 / 10, (uint64_t) args.status.progress_1000 % 10); else tprints("???"); tprints(" */ ,"); time = args.status.time_started; strftime(buf, sizeof(buf), "%T", localtime(&time)); tprintf("time_started=%" PRIu64" /* %s */, ", (uint64_t) args.status.time_started, buf); time = args.status.time_stopped; strftime(buf, sizeof(buf), "%T", localtime(&time)); tprintf("time_stopped=%" PRIu64" /* %s */, ", (uint64_t) args.status.time_stopped, buf); tprintf("num_write_errors=%" PRIu64 ", num_uncorrectable_read_errors=%" PRIu64, (uint64_t) args.status.num_write_errors, (uint64_t) args.status.num_uncorrectable_read_errors); } tprints("}"); break; } case BTRFS_IOC_GET_FEATURES: { /* R */ struct btrfs_ioctl_feature_flags flags; if (entering(tcp)) return 0; tprints(", "); if (umove_or_printaddr(tcp, arg, &flags)) break; btrfs_print_features(&flags); break; } case BTRFS_IOC_SET_FEATURES: { /* W */ struct btrfs_ioctl_feature_flags flarg[2]; tprints(", "); if (umove_or_printaddr(tcp, arg, &flarg)) break; tprints("["); btrfs_print_features(&flarg[0]); tprints(", "); btrfs_print_features(&flarg[1]); tprints("]"); break; } case BTRFS_IOC_GET_SUPPORTED_FEATURES: { /* R */ struct btrfs_ioctl_feature_flags flarg[3]; if (entering(tcp)) return 0; tprints(", "); if (umove_or_printaddr(tcp, arg, &flarg)) break; tprints("[ /* supported */ "); btrfs_print_features(&flarg[0]); tprints(", /* safe to set */ "); btrfs_print_features(&flarg[1]); tprints(", /* safe to clear */ "); btrfs_print_features(&flarg[2]); tprints("]"); break; } case BTRFS_IOC_FS_INFO: { /* R */ struct btrfs_ioctl_fs_info_args args; char uuid[UUID_STRING_SIZE+1]; uint32_t nodesize, sectorsize, clone_alignment; #ifndef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE __u32 *reserved32; #endif if (entering(tcp)) return 0; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; #ifdef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE nodesize = args.nodesize, sectorsize = args.sectorsize, clone_alignment = args.clone_alignment; #else reserved32 = (__u32 *) (void *) args.reserved; nodesize = reserved32[0]; sectorsize = reserved32[1]; clone_alignment = reserved32[2]; #endif btrfs_unparse_uuid(args.fsid, uuid); tprints("{"); tprintf("max_id=%" PRI__u64 ", num_devices=%" PRI__u64 ", fsid=%s, nodesize=%u, sectorsize=%u" ", clone_alignment=%u", args.max_id, args.num_devices, uuid, nodesize, sectorsize, clone_alignment); tprints("}"); break; } case BTRFS_IOC_GET_DEV_STATS: { /* RW */ struct btrfs_ioctl_get_dev_stats args; uint64_t i; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; tprints("{"); if (entering(tcp)) tprintf("devid=%" PRI__u64 ", ", args.devid); tprintf("nr_items=%" PRI__u64 ", flags=", args.nr_items); printflags64(btrfs_dev_stats_flags, args.flags, "BTRFS_DEV_STATS_???"); if (entering(tcp)) { tprints("}"); return 0; } /* * The structure has a 1k limit; Let's make sure we don't * go off into the middle of nowhere with a bad nr_items * value. */ tprints(", ["); for (i = 0; i < args.nr_items; i++) { if (i) tprints(", "); if (i >= ARRAY_SIZE(args.values)) { tprints("..."); break; } const char *name = xlookup(btrfs_dev_stats_values, i); if (name) tprintf("/* %s */ ", name); tprintf("%" PRI__u64, args.values[i]); } tprints("]}"); break; } case BTRFS_IOC_INO_LOOKUP: { /* RW */ struct btrfs_ioctl_ino_lookup_args args; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; if (entering(tcp)) { /* Use subvolume id of the containing root */ if (args.treeid == 0) set_tcb_priv_ulong(tcp, 1); tprints("{treeid="); btrfs_print_objectid(args.treeid); tprints(", objectid="); btrfs_print_objectid(args.objectid); tprints("}"); return 0; } tprints("{"); if (get_tcb_priv_ulong(tcp)) { tprints("treeid="); btrfs_print_objectid(args.treeid); tprints(", "); } tprints("name="); print_quoted_string(args.name, sizeof(args.name), QUOTE_0_TERMINATED); tprints("}"); break; } case BTRFS_IOC_INO_PATHS: { /* RW */ struct btrfs_ioctl_ino_path_args args; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; tprints("{"); if (entering(tcp)) { tprintf("inum=%" PRI__u64 ", size=%" PRI__u64, args.inum, args.size); tprintf(", fspath=0x%" PRI__x64 "}", args.fspath); return 0; } tprints("fspath="); btrfs_print_ino_path_container(tcp, args.fspath); tprints("}"); break; } case BTRFS_IOC_LOGICAL_INO: { /* RW */ struct btrfs_ioctl_logical_ino_args args; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; tprints("{"); if (entering(tcp)) { tprintf("logical=%" PRI__u64 ", size=%" PRI__u64, args.logical, args.size); tprintf(", inodes=0x%" PRI__x64 "}", args.inodes); return 0; } tprints("inodes="); btrfs_print_logical_ino_container(tcp, args.inodes); tprints("}"); break; } case BTRFS_IOC_QGROUP_ASSIGN: { /* W */ struct btrfs_ioctl_qgroup_assign_args args; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprintf("{assign=%" PRI__u64 ", src=%" PRI__u64 ", dst=%" PRI__u64 "}", args.assign, args.src, args.dst); break; } case BTRFS_IOC_QGROUP_CREATE: { /* W */ struct btrfs_ioctl_qgroup_create_args args; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprintf("{create=%" PRI__u64 ", qgroupid=%" PRI__u64 "}", args.create, args.qgroupid); break; } case BTRFS_IOC_QGROUP_LIMIT: { /* R */ struct btrfs_ioctl_qgroup_limit_args args; if (entering(tcp)) return 0; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprintf("{qgroupid=%" PRI__u64 ", lim=", args.qgroupid); btrfs_print_qgroup_limit(&args.lim); tprints("}"); break; } case BTRFS_IOC_QUOTA_CTL: { /* W */ struct btrfs_ioctl_quota_ctl_args args; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; printxval64(btrfs_qgroup_ctl_cmds, args.cmd, "BTRFS_QUOTA_CTL_???"); tprints("}"); break; } case BTRFS_IOC_QUOTA_RESCAN: { /* W */ struct btrfs_ioctl_quota_rescan_args args; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprintf("{flags=%" PRIu64 "}", (uint64_t) args.flags); break; } case BTRFS_IOC_QUOTA_RESCAN_STATUS: { /* R */ struct btrfs_ioctl_quota_rescan_args args; if (entering(tcp)) return 0; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprintf("{flags=%" PRIu64 ", progress=", (uint64_t) args.flags); btrfs_print_objectid(args.progress); tprints("}"); break; } case BTRFS_IOC_SET_RECEIVED_SUBVOL: { /* RW */ struct_btrfs_ioctl_received_subvol_args args; char uuid[UUID_STRING_SIZE+1]; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; if (entering(tcp)) { btrfs_unparse_uuid((unsigned char *)args.uuid, uuid); tprintf("{uuid=%s, stransid=%" PRIu64 ", stime=%" PRIu64 ".%u, flags=%" PRIu64 "}", uuid, (uint64_t) args.stransid, (uint64_t) args.stime.sec, args.stime.nsec, (uint64_t) args.flags); return 0; } tprintf("{rtransid=%" PRIu64 ", rtime=%" PRIu64 ".%u}", (uint64_t) args.rtransid, (uint64_t) args.rtime.sec, args.rtime.nsec); break; } case BTRFS_IOC_SCRUB: /* RW */ case BTRFS_IOC_SCRUB_PROGRESS: { /* RW */ struct btrfs_ioctl_scrub_args args; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; if (entering(tcp)) { tprintf("{devid=%" PRI__u64, args.devid); if (code == BTRFS_IOC_SCRUB) { tprintf(", start=%" PRI__u64 ", end=", args.start); tprintf("%" PRI__u64, args.end); if (args.end == UINT64_MAX) tprints(" /* UINT64_MAX */"); tprints(", flags="); printflags64(btrfs_scrub_flags, args.flags, "BTRFS_SCRUB_???"); } tprints("}"); return 0; } tprintf("{data_extents_scrubbed=%" PRI__u64 ", tree_extents_scrubbed=%" PRI__u64 ", data_bytes_scrubbed=%" PRI__u64 ", tree_bytes_scrubbed=%" PRI__u64 ", read_errors=%" PRI__u64 ", csum_errors=%" PRI__u64 ", verify_errors=%" PRI__u64 ", no_csum=%" PRI__u64 ", csum_discards=%" PRI__u64 ", super_errors=%" PRI__u64 ", malloc_errors=%" PRI__u64 ", uncorrectable_errors=%" PRI__u64 ", corrected_errors=%" PRI__u64 ", last_physical=%" PRI__u64 ", unverified_errors=%" PRI__u64 "}", args.progress.data_extents_scrubbed, args.progress.tree_extents_scrubbed, args.progress.data_bytes_scrubbed, args.progress.tree_bytes_scrubbed, args.progress.read_errors, args.progress.csum_errors, args.progress.verify_errors, args.progress.no_csum, args.progress.csum_discards, args.progress.super_errors, args.progress.malloc_errors, args.progress.uncorrectable_errors, args.progress.corrected_errors, args.progress.last_physical, args.progress.unverified_errors); break; } case BTRFS_IOC_TREE_SEARCH: { /* RW */ struct btrfs_ioctl_search_args args; uint64_t buf_offset; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; buf_offset = offsetof(struct btrfs_ioctl_search_args, buf); btrfs_print_tree_search(tcp, &args.key, arg + buf_offset, sizeof(args.buf), false); if (entering(tcp)) return 0; break; } case BTRFS_IOC_TREE_SEARCH_V2: { /* RW */ struct btrfs_ioctl_search_args_v2 args; uint64_t buf_offset; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) { if (tcp->u_error == EOVERFLOW) { tprints(" => "); tcp->u_error = 0; if (!umove_or_printaddr(tcp, arg, &args)) tprintf("{buf_size=%" PRIu64 "}", (uint64_t)args.buf_size); tcp->u_error = EOVERFLOW; } break; } else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; buf_offset = offsetof(struct btrfs_ioctl_search_args_v2, buf); btrfs_print_tree_search(tcp, &args.key, arg + buf_offset, args.buf_size, true); if (entering(tcp)) return 0; break; } case BTRFS_IOC_SEND: { /* W */ struct_btrfs_ioctl_send_args args; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprints("{send_fd="); printfd(tcp, args.send_fd); tprintf(", clone_sources_count=%" PRIu64 ", clone_sources=", (uint64_t) args.clone_sources_count); if (abbrev(tcp)) tprints("..."); else { uint64_t record; print_array(tcp, (unsigned long) args.clone_sources, args.clone_sources_count, &record, sizeof(record), umoven_or_printaddr, print_objectid_callback, 0); } tprints(", parent_root="); btrfs_print_objectid(args.parent_root); tprints(", flags="); printflags64(btrfs_send_flags, args.flags, "BTRFS_SEND_FLAGS_???"); tprints("}"); break; } case BTRFS_IOC_SPACE_INFO: { /* RW */ struct btrfs_ioctl_space_args args; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; tprints("{"); if (entering(tcp)) { tprintf("space_slots=%" PRI__u64 "}", args.space_slots); return 0; } tprintf("total_spaces=%" PRI__u64, args.total_spaces); if (args.space_slots == 0 && args.total_spaces) { tprints("}"); break; } tprints(", spaces="); if (abbrev(tcp)) tprints("..."); else { struct btrfs_ioctl_space_info info; print_array(tcp, arg + offsetof(typeof(args), spaces), args.total_spaces, &info, sizeof(info), umoven_or_printaddr, print_btrfs_ioctl_space_info, 0); } tprints("}"); break; } case BTRFS_IOC_SNAP_CREATE: case BTRFS_IOC_RESIZE: case BTRFS_IOC_SCAN_DEV: case BTRFS_IOC_ADD_DEV: case BTRFS_IOC_RM_DEV: case BTRFS_IOC_SUBVOL_CREATE: case BTRFS_IOC_SNAP_DESTROY: case BTRFS_IOC_DEVICES_READY: { /* W */ struct btrfs_ioctl_vol_args args; tprints(", "); if (umove_or_printaddr(tcp, arg, &args)) break; tprints("{fd="); printfd(tcp, args.fd); tprints(", name="); print_quoted_string(args.name, sizeof(args.name), QUOTE_0_TERMINATED); tprints("}"); break; } case BTRFS_IOC_SNAP_CREATE_V2: case BTRFS_IOC_SUBVOL_CREATE_V2: { /* code is W, but is actually RW */ struct btrfs_ioctl_vol_args_v2 args; if (entering(tcp)) tprints(", "); else if (syserror(tcp)) break; else tprints(" => "); if (umove_or_printaddr(tcp, arg, &args)) break; if (entering(tcp)) { tprints("{fd="); printfd(tcp, args.fd); tprints(", flags="); printflags64(btrfs_snap_flags_v2, args.flags, "BTRFS_SUBVOL_???"); if (args.flags & BTRFS_SUBVOL_QGROUP_INHERIT) { tprintf(", size=%" PRI__u64 ", qgroup_inherit=", args.size); btrfs_print_qgroup_inherit(tcp, (unsigned long)args.qgroup_inherit); } tprintf(", name="); print_quoted_string(args.name, sizeof(args.name), QUOTE_0_TERMINATED); tprints("}"); return 0; } tprintf("{transid=%" PRI__u64 "}", args.transid); break; } case BTRFS_IOC_GET_FSLABEL: /* R */ if (entering(tcp)) return 0; /* fall through */ case BTRFS_IOC_SET_FSLABEL: { /* W */ char label[BTRFS_LABEL_SIZE]; tprints(", "); if (umove_or_printaddr(tcp, arg, &label)) break; print_quoted_string(label, sizeof(label), QUOTE_0_TERMINATED); break; } case BTRFS_IOC_CLONE: /* FICLONE */ case BTRFS_IOC_CLONE_RANGE: /* FICLONERANGE */ #ifdef BTRFS_IOC_FILE_EXTENT_SAME case BTRFS_IOC_FILE_EXTENT_SAME: /* FIDEDUPERANGE */ #endif /* * FICLONE, FICLONERANGE, and FIDEDUPERANGE started out as * btrfs ioctls and the code was kept for the generic * implementations. We use the BTRFS_* names here because * they will be available on older systems. */ return file_ioctl(tcp, code, arg); default: return RVAL_DECODED; }; return RVAL_DECODED | 1; }
MPERS_PRINTER_DECL(int, mtd_ioctl, struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg) { switch (code) { case MEMERASE: case MEMLOCK: case MEMUNLOCK: case MEMISLOCKED: decode_erase_info_user(tcp, arg); break; case MEMERASE64: decode_erase_info_user64(tcp, arg); break; case MEMWRITEOOB: case MEMREADOOB: decode_mtd_oob_buf(tcp, arg); break; case MEMWRITEOOB64: case MEMREADOOB64: decode_mtd_oob_buf64(tcp, arg); break; case MEMWRITE: decode_mtd_write_req(tcp, arg); break; case OTPGETREGIONINFO: if (entering(tcp)) return 0; /* fall through */ case OTPLOCK: decode_otp_info(tcp, arg); break; case OTPSELECT: decode_otp_select(tcp, arg); break; case MTDFILEMODE: tprints(", "); printxval64(mtd_file_mode_options, arg, "MTD_FILE_MODE_???"); break; case MEMGETBADBLOCK: case MEMSETBADBLOCK: tprints(", "); printnum_int64(tcp, arg, "%" PRIu64); break; case MEMGETINFO: if (entering(tcp)) return 0; decode_mtd_info_user(tcp, arg); break; case MEMGETOOBSEL: if (entering(tcp)) return 0; decode_nand_oobinfo(tcp, arg); break; case ECCGETLAYOUT: if (entering(tcp)) return 0; decode_nand_ecclayout_user(tcp, arg); break; case ECCGETSTATS: if (entering(tcp)) return 0; decode_mtd_ecc_stats(tcp, arg); break; case OTPGETREGIONCOUNT: if (entering(tcp)) return 0; tprints(", "); printnum_int(tcp, arg, "%u"); break; case MEMGETREGIONCOUNT: if (entering(tcp)) return 0; tprints(", "); printnum_int(tcp, arg, "%d"); break; case MEMGETREGIONINFO: if (entering(tcp)) { struct region_info_user rinfo; tprints(", "); if (umove_or_printaddr(tcp, arg, &rinfo)) break; tprintf("{regionindex=%#x", rinfo.regionindex); return 0; } else { struct region_info_user rinfo; if (!syserror(tcp) && !umove(tcp, arg, &rinfo)) tprintf(", offset=%#x" ", erasesize=%#x" ", numblocks=%#x}", rinfo.offset, rinfo.erasesize, rinfo.numblocks); tprints("}"); break; } default: return RVAL_DECODED; } return RVAL_IOCTL_DECODED; }