void render_sigset_t(struct seq_file *m, const char *header, sigset_t *set) { int i; seq_puts(m, header); i = _NSIG; do { int x = 0; i -= 4; if (sigismember(set, i+1)) x |= 1; if (sigismember(set, i+2)) x |= 2; if (sigismember(set, i+3)) x |= 4; if (sigismember(set, i+4)) x |= 8; seq_printf(m, "%x", x); } while (i >= 4); seq_putc(m, '\n'); }
static int read_file_queues(struct seq_file *file, void *data) { struct ieee80211_hw *hw = dev_get_drvdata(file->private); struct ath_softc *sc = hw->priv; struct ath_txq *txq; int i; static const char *qname[4] = { "VO", "VI", "BE", "BK" }; for (i = 0; i < IEEE80211_NUM_ACS; i++) { txq = sc->tx.txq_map[i]; seq_printf(file, "(%s): ", qname[i]); print_queue(sc, txq, file); } seq_puts(file, "(CAB): "); print_queue(sc, sc->beacon.cabq, file); return 0; }
static int vlan_seq_show(struct seq_file *seq, void *v) { if (v == SEQ_START_TOKEN) { const char *nmtype = NULL; seq_puts(seq, "VLAN Dev name | VLAN ID\n"); if (vlan_name_type < ARRAY_SIZE(vlan_name_type_str)) nmtype = vlan_name_type_str[vlan_name_type]; seq_printf(seq, "Name-Type: %s\n", nmtype ? nmtype : "UNKNOWN" ); } else { const struct net_device *vlandev = v; const struct vlan_dev_info *dev_info = VLAN_DEV_INFO(vlandev); seq_printf(seq, "%-15s| %d | %s\n", vlandev->name, dev_info->vlan_id, dev_info->real_dev->name); } return 0; }
static int show_partition(struct seq_file *part, void *v) { struct gendisk *sgp = v; int n; char buf[BDEVNAME_SIZE]; struct hd_struct *hd_part; if (&sgp->kobj.entry == block_subsys.kset.list.next) seq_puts(part, "major minor #blocks name\n\n"); /* Don't show non-partitionable removeable devices or empty devices */ if (!get_capacity(sgp) || (sgp->minors == 1 && (sgp->flags & GENHD_FL_REMOVABLE))) return 0; if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO) return 0; /* show the full disk and all non-0 size partitions of it */ seq_printf(part, "%4d %4d %10llu %s\n", sgp->major, sgp->first_minor, (unsigned long long)get_capacity(sgp) >> 1, disk_name(sgp, 0, buf)); for (n = 0; n < sgp->minors - 1; n++) { rcu_read_lock(); hd_part = rcu_dereference(sgp->part[n]); if ((!hd_part) || (hd_part->nr_sects == 0)) { rcu_read_unlock(); continue; } seq_printf(part, "%4d %4d %10llu %s\n", sgp->major, n + 1 + sgp->first_minor, (unsigned long long)hd_part->nr_sects >> 1, disk_name(sgp, n + 1, buf)); rcu_read_unlock(); } return 0; }
void xprt_rdma_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) { struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt); long idle_time = 0; if (xprt_connected(xprt)) idle_time = (long)(jiffies - xprt->last_used) / HZ; seq_puts(seq, "\txprt:\trdma "); seq_printf(seq, "%u %lu %lu %lu %ld %lu %lu %lu %llu %llu ", 0, /* need a local port? */ xprt->stat.bind_count, xprt->stat.connect_count, xprt->stat.connect_time / HZ, idle_time, xprt->stat.sends, xprt->stat.recvs, xprt->stat.bad_xids, xprt->stat.req_u, xprt->stat.bklog_u); seq_printf(seq, "%lu %lu %lu %llu %llu %llu %llu %lu %lu %lu %lu ", r_xprt->rx_stats.read_chunk_count, r_xprt->rx_stats.write_chunk_count, r_xprt->rx_stats.reply_chunk_count, r_xprt->rx_stats.total_rdma_request, r_xprt->rx_stats.total_rdma_reply, r_xprt->rx_stats.pullup_copy_count, r_xprt->rx_stats.fixup_copy_count, r_xprt->rx_stats.hardway_register_count, r_xprt->rx_stats.failed_marshal_count, r_xprt->rx_stats.bad_reply_count, r_xprt->rx_stats.nomsg_call_count); seq_printf(seq, "%lu %lu %lu %lu %lu %lu\n", r_xprt->rx_stats.mrs_recycled, r_xprt->rx_stats.mrs_orphaned, r_xprt->rx_stats.mrs_allocated, r_xprt->rx_stats.local_inv_needed, r_xprt->rx_stats.empty_sendctx_q, r_xprt->rx_stats.reply_waits_for_send); }
/* * show_interrupts() * Return a string that displays the state of each of the interrupts. */ int show_interrupts(struct seq_file *p, void *v) { struct irqaction *ap; int irq = *((loff_t *) v); struct irq_desc *desc = irq_to_desc(irq); int j; if (irq >= NR_IRQS) { return 0; } if (irq == 0) { seq_puts(p, " "); for_each_online_cpu(j) { seq_printf(p, "CPU%d ", j); } #if defined(IRQ_REENTRANT_COUNT) seq_printf(p, "Reentrant?"); #endif seq_putc(p, '\n'); }
static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset) { struct acpi_processor *pr = seq->private; if (!pr) goto end; if (!pr->flags.limit) { seq_puts(seq, "<not supported>\n"); goto end; } seq_printf(seq, "active limit: P%d:T%d\n" "user limit: P%d:T%d\n" "thermal limit: P%d:T%d\n", pr->limit.state.px, pr->limit.state.tx, pr->limit.user.px, pr->limit.user.tx, pr->limit.thermal.px, pr->limit.thermal.tx); end: return 0; }
/* Display information about each subsystem and each hierarchy */ int proc_cgroupstats_show(struct seq_file *m, void *v) { struct cgroup_subsys *ss; int i; seq_puts(m, "#subsys_name\thierarchy\tnum_cgroups\tenabled\n"); /* * ideally we don't want subsystems moving around while we do this. * cgroup_mutex is also necessary to guarantee an atomic snapshot of * subsys/hierarchy state. */ mutex_lock(&cgroup_mutex); for_each_subsys(ss, i) seq_printf(m, "%s\t%d\t%d\t%d\n", ss->legacy_name, ss->root->hierarchy_id, atomic_read(&ss->root->nr_cgrps), cgroup_ssid_enabled(i)); mutex_unlock(&cgroup_mutex); return 0; }
static int udelay_test_single(struct seq_file *s, int usecs, uint32_t iters) { int min = 0, max = 0, fail_count = 0; uint64_t sum = 0; uint64_t avg; int i; /* Allow udelay to be up to 0.5% fast */ int allowed_error_ns = usecs * 5; for (i = 0; i < iters; ++i) { s64 kt1, kt2; int time_passed; kt1 = ktime_get_ns(); udelay(usecs); kt2 = ktime_get_ns(); time_passed = kt2 - kt1; if (i == 0 || time_passed < min) min = time_passed; if (i == 0 || time_passed > max) max = time_passed; if ((time_passed + allowed_error_ns) / 1000 < usecs) ++fail_count; WARN_ON(time_passed < 0); sum += time_passed; } avg = sum; do_div(avg, iters); seq_printf(s, "%d usecs x %d: exp=%d allowed=%d min=%d avg=%lld max=%d", usecs, iters, usecs * 1000, (usecs * 1000) - allowed_error_ns, min, avg, max); if (fail_count) seq_printf(s, " FAIL=%d", fail_count); seq_puts(s, "\n"); return 0; }
int show_interrupts(struct seq_file *p, void *v) { int j, i = *(loff_t *) v; struct irqaction * action; irq_desc_t *idesc; unsigned long flags; if (i == 0) { seq_puts(p, " "); for (j=0; j<NR_CPUS; j++) if (cpu_online(j)) seq_printf(p, "CPU%d ",j); seq_putc(p, '\n'); } if (i < NR_IRQS) { idesc = irq_descp(i); spin_lock_irqsave(&idesc->lock, flags); action = idesc->action; if (!action) goto skip; seq_printf(p, "%3d: ",i); #ifndef CONFIG_SMP seq_printf(p, "%10u ", kstat_irqs(i)); #else for (j = 0; j < NR_CPUS; j++) if (cpu_online(j)) seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]); #endif seq_printf(p, " %14s", idesc->handler->typename); seq_printf(p, " %s", action->name); for (action=action->next; action; action = action->next) seq_printf(p, ", %s", action->name); seq_putc(p, '\n'); skip: spin_unlock_irqrestore(&idesc->lock, flags); } else if (i == NR_IRQS) {
/* the /proc function: allocate everything to allow concurrency. */ static int jit_tasklet_proc_show(struct seq_file *m, void *v) { struct jit_data *data; unsigned long j = jiffies; long hi = (long)m->private; data = kmalloc(sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; init_waitqueue_head (&data->wait); /* Write the first lines in the buffer. */ seq_puts(m, " time delta inirq pid cpu command\n"); seq_printf(m, "%9li %3li %i %6i %i %s\n", j, 0L, in_interrupt() ? 1 : 0, current->pid, smp_processor_id(), current->comm); /* Fill the data for our tasklet function. */ data->prevjiffies = j; data->m = m; data->loops = JIT_ASYNC_LOOPS; /* Register the tasklet. */ tasklet_init(&data->tlet, jit_tasklet_fn, (unsigned long)data); data->hi = hi; if (hi) tasklet_hi_schedule(&data->tlet); else tasklet_schedule(&data->tlet); /* Wait for the buffer to fill. */ wait_event_interruptible(data->wait, !data->loops); if (signal_pending(current)) return -ERESTARTSYS; kfree(data); return 0; }
static int qla_dfs_fw_resource_cnt_show(struct seq_file *s, void *unused) { struct scsi_qla_host *vha = s->private; struct qla_hw_data *ha = vha->hw; seq_puts(s, "FW Resource count\n\n"); seq_printf(s, "Original TGT exchg count[%d]\n", ha->orig_fw_tgt_xcb_count); seq_printf(s, "current TGT exchg count[%d]\n", ha->cur_fw_tgt_xcb_count); seq_printf(s, "original Initiator Exchange count[%d]\n", ha->orig_fw_xcb_count); seq_printf(s, "Current Initiator Exchange count[%d]\n", ha->cur_fw_xcb_count); seq_printf(s, "Original IOCB count[%d]\n", ha->orig_fw_iocb_count); seq_printf(s, "Current IOCB count[%d]\n", ha->cur_fw_iocb_count); seq_printf(s, "MAX VP count[%d]\n", ha->max_npiv_vports); seq_printf(s, "MAX FCF count[%d]\n", ha->fw_max_fcf_count); return 0; }
/* * Display the list of cells known to the namespace. */ static int afs_proc_cells_show(struct seq_file *m, void *v) { struct afs_vlserver_list *vllist; struct afs_cell *cell; if (v == SEQ_START_TOKEN) { /* display header on line 1 */ seq_puts(m, "USE TTL SV NAME\n"); return 0; } cell = list_entry(v, struct afs_cell, proc_link); vllist = rcu_dereference(cell->vl_servers); /* display one cell per line on subsequent lines */ seq_printf(m, "%3u %6lld %2u %s\n", atomic_read(&cell->usage), cell->dns_expiry - ktime_get_real_seconds(), vllist ? vllist->nr_servers : 0, cell->name); return 0; }
static int wakeup_reason_stats_show(struct seq_file *s, void *unused) { int i; seq_puts(s, "eint_no\tirq\twakeup_count\tname\n"); for (i = 0; i < NR_EINT; i++) { struct irq_desc *desc = irq_to_desc(wakeup_reason_stats[i].irq); const char *irq_name = NULL; if (!wakeup_reason_stats[i].irq) continue; if (desc && desc->action && desc->action->name) irq_name = desc->action->name; seq_printf(s, "%d\t%d\t%u\t\t%s\n", i, wakeup_reason_stats[i].irq, wakeup_reason_stats[i].wakeup_count, irq_name); } return 0; }
static int show_rcudata_csv(struct seq_file *m, void *unused) { seq_puts(m, "\"CPU\",\"Online?\",\"c\",\"g\",\"pq\",\"pqc\",\"pq\","); #ifdef CONFIG_NO_HZ seq_puts(m, "\"dt\",\"dt nesting\",\"dn\",\"df\","); #endif /* #ifdef CONFIG_NO_HZ */ seq_puts(m, "\"of\",\"ri\",\"ql\",\"b\",\"ci\",\"co\",\"ca\"\n"); #ifdef CONFIG_TREE_PREEMPT_RCU seq_puts(m, "\"rcu_preempt:\"\n"); PRINT_RCU_DATA(rcu_preempt_data, print_one_rcu_data_csv, m); #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */ seq_puts(m, "\"rcu_sched:\"\n"); PRINT_RCU_DATA(rcu_sched_data, print_one_rcu_data_csv, m); seq_puts(m, "\"rcu_bh:\"\n"); PRINT_RCU_DATA(rcu_bh_data, print_one_rcu_data_csv, m); return 0; }
static inline void task_name(struct seq_file *m, struct task_struct *p) { int i; char *buf, *end; char *name; char tcomm[sizeof(p->comm)]; get_task_comm(tcomm, p); seq_puts(m, "Name:\t"); end = m->buf + m->size; buf = m->buf + m->count; name = tcomm; i = sizeof(tcomm); while (i && (buf < end)) { unsigned char c = *name; name++; i--; *buf = c; if (!c) break; if (c == '\\') { buf++; if (buf < end) *buf++ = c; continue; } if (c == '\n') { *buf++ = '\\'; if (buf < end) *buf++ = 'n'; continue; } buf++; } m->count = buf - m->buf; seq_putc(m, '\n'); }
static int jit_timer_proc_show(struct seq_file *m, void *v) /******************************************************************************/ { struct jit_data *data; unsigned long j = jiffies; data = kmalloc(sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; init_timer(&data->timer); init_waitqueue_head (&data->wait); /* write the first lines in the buffer */ seq_puts(m, " time delta inirq pid cpu command\n"); seq_printf(m, "%9li %3li %i %6i %i %s\n", j, 0L, in_interrupt() ? 1 : 0, current->pid, smp_processor_id(), current->comm); /* fill the data for our timer function */ data->prevjiffies = j; data->m = m; data->loops = JIT_ASYNC_LOOPS; /* register the timer */ data->timer.data = (unsigned long)data; data->timer.function = jit_timer_fn; data->timer.expires = j + tdelay; /* parameter */ add_timer(&data->timer); /* wait for the buffer to fill */ wait_event_interruptible(data->wait, !data->loops); if (signal_pending(current)) return -ERESTARTSYS; kfree(data); return 0; }
/* Called from pincontrol core */ static int pinmux_functions_show(struct seq_file *s, void *what) { struct pinctrl_dev *pctldev = s->private; const struct pinmux_ops *pmxops = pctldev->desc->pmxops; unsigned nfuncs; unsigned func_selector = 0; if (!pmxops) return 0; mutex_lock(&pinctrl_mutex); nfuncs = pmxops->get_functions_count(pctldev); while (func_selector < nfuncs) { const char *func = pmxops->get_function_name(pctldev, func_selector); const char * const *groups; unsigned num_groups; int ret; int i; ret = pmxops->get_function_groups(pctldev, func_selector, &groups, &num_groups); if (ret) seq_printf(s, "function %s: COULD NOT GET GROUPS\n", func); seq_printf(s, "function: %s, groups = [ ", func); for (i = 0; i < num_groups; i++) seq_printf(s, "%s ", groups[i]); seq_puts(s, "]\n"); func_selector++; } mutex_unlock(&pinctrl_mutex); return 0; }
static void imx1_pinconf_group_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s, unsigned group) { struct imx1_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); const struct imx1_pinctrl_soc_info *info = ipctl->info; struct imx1_pin_group *grp; unsigned long config; const char *name; int i, ret; if (group > info->ngroups) return; seq_puts(s, "\n"); grp = &info->groups[group]; for (i = 0; i < grp->npins; i++) { name = pin_get_name(pctldev, grp->pins[i].pin_id); ret = imx1_pinconf_get(pctldev, grp->pins[i].pin_id, &config); if (ret) return; seq_printf(s, "%s: 0x%lx", name, config); } }
static int send_host_cmd_v_blank_dcs(struct seq_file *s, void *unused) { struct tegra_dc_dsi_data *dsi = s->private; int err; struct tegra_dsi_cmd user_command[] = { DSI_CMD_SHORT(data_id, command_value, command_value1), DSI_DLY_MS(20), }; if (!dsi->enabled) { seq_puts(s, "DSI controller suspended\n"); return 0; } seq_printf(s, "data_id taken :0x%x\n", data_id); seq_printf(s, "command value taken :0x%x\n", command_value); seq_printf(s, "second command value taken :0x%x\n", command_value1); err = tegra_dsi_start_host_cmd_v_blank_dcs(dsi, user_command); return err; }
/* * /proc/interrupts printing for arch specific interrupts */ int arch_show_interrupts(struct seq_file *p, int prec) { int j; #ifdef CONFIG_DEBUG_STACKOVERFLOW seq_printf(p, "%*s: ", prec, "STK"); for_each_online_cpu(j) seq_printf(p, "%10u ", irq_stats(j)->kernel_stack_usage); seq_puts(p, " Kernel stack usage\n"); # ifdef CONFIG_IRQSTACKS seq_printf(p, "%*s: ", prec, "IST"); for_each_online_cpu(j) seq_printf(p, "%10u ", irq_stats(j)->irq_stack_usage); seq_puts(p, " Interrupt stack usage\n"); # endif #endif #ifdef CONFIG_SMP seq_printf(p, "%*s: ", prec, "RES"); for_each_online_cpu(j) seq_printf(p, "%10u ", irq_stats(j)->irq_resched_count); seq_puts(p, " Rescheduling interrupts\n"); seq_printf(p, "%*s: ", prec, "CAL"); for_each_online_cpu(j) seq_printf(p, "%10u ", irq_stats(j)->irq_call_count); seq_puts(p, " Function call interrupts\n"); #endif seq_printf(p, "%*s: ", prec, "UAH"); for_each_online_cpu(j) seq_printf(p, "%10u ", irq_stats(j)->irq_unaligned_count); seq_puts(p, " Unaligned access handler traps\n"); seq_printf(p, "%*s: ", prec, "FPA"); for_each_online_cpu(j) seq_printf(p, "%10u ", irq_stats(j)->irq_fpassist_count); seq_puts(p, " Floating point assist traps\n"); seq_printf(p, "%*s: ", prec, "TLB"); for_each_online_cpu(j) seq_printf(p, "%10u ", irq_stats(j)->irq_tlb_count); seq_puts(p, " TLB shootdowns\n"); return 0; }
static int segment_bits_seq_show(struct seq_file *seq, void *offset) { struct super_block *sb = seq->private; struct f2fs_sb_info *sbi = F2FS_SB(sb); unsigned int total_segs = le32_to_cpu(sbi->raw_super->segment_count_main); int i, j; seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n" "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); for (i = 0; i < total_segs; i++) { struct seg_entry *se = get_seg_entry(sbi, i); seq_printf(seq, "%-10d", i); seq_printf(seq, "%d|%-3u|", se->type, get_valid_blocks(sbi, i, false)); for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++) seq_printf(seq, " %.2x", se->cur_valid_map[j]); seq_putc(seq, '\n'); } return 0; }
static int ux500_regulator_status_print(struct seq_file *s, void *p) { int i; /* print dump header */ seq_puts(s, "ux500-regulator status:\n"); seq_printf(s, "%31s : %8s : %8s\n", "current", "before", "after"); for (i = 0; i < rdebug.num_regulators; i++) { struct dbx500_regulator_info *info; /* Access per-regulator data */ info = &rdebug.regulator_array[i]; /* print status */ seq_printf(s, "%20s : %8s : %8s : %8s\n", info->desc.name, info->is_enabled ? "enabled" : "disabled", rdebug.state_before_suspend[i] ? "enabled" : "disabled", rdebug.state_after_suspend[i] ? "enabled" : "disabled"); } return 0; }
static int pn_sock_seq_show(struct seq_file *seq, void *v) { seq_setwidth(seq, 127); if (v == SEQ_START_TOKEN) seq_puts(seq, "pt loc rem rs st tx_queue rx_queue " " uid inode ref pointer drops"); else { struct sock *sk = v; struct pn_sock *pn = pn_sk(sk); seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu " "%d %pK %d", sk->sk_protocol, pn->sobject, pn->dobject, pn->resource, sk->sk_state, sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk), from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)), sock_i_ino(sk), atomic_read(&sk->sk_refcnt), sk, atomic_read(&sk->sk_drops)); } seq_pad(seq, '\n'); return 0; }
static int esdfs_show_options(struct seq_file *seq, struct dentry *root) { struct esdfs_sb_info *sbi = ESDFS_SB(root->d_sb); if (memcmp(&sbi->lower_perms, &esdfs_perms_table[ESDFS_PERMS_LOWER_DEFAULT], sizeof(struct esdfs_perms))) seq_printf(seq, ",lower=%u:%u:%ho:%ho", sbi->lower_perms.uid, sbi->lower_perms.gid, sbi->lower_perms.fmask, sbi->lower_perms.dmask); if (memcmp(&sbi->upper_perms, &esdfs_perms_table[ESDFS_PERMS_UPPER_LEGACY], sizeof(struct esdfs_perms))) seq_printf(seq, ",upper=%u:%u:%ho:%ho", sbi->upper_perms.uid, sbi->upper_perms.gid, sbi->upper_perms.fmask, sbi->upper_perms.dmask); if (test_opt(sbi, DERIVE_PUBLIC)) seq_puts(seq, ",derive=public"); else if (test_opt(sbi, DERIVE_MULTI)) seq_puts(seq, ",derive=multi"); else if (test_opt(sbi, DERIVE_UNIFIED)) seq_puts(seq, ",derive=unified"); else if (test_opt(sbi, DERIVE_LEGACY)) seq_puts(seq, ",derive=legacy"); else seq_puts(seq, ",derive=none"); if (test_opt(sbi, DERIVE_CONFINE)) seq_puts(seq, ",confine"); else seq_puts(seq, ",noconfine"); return 0; }
static void *as_start(struct seq_file *m, loff_t *pos) { int i; loff_t n = *pos; if (!n) { seq_printf(m, "total bytes allocated: %8d\n", kma_total); seq_printf(m, "slack bytes allocated: %8d\n", kma_slack); seq_printf(m, "net bytes allocated: %8d\n", kma_net); seq_printf(m, "number of allocs: %8d\n", kma_allocs); seq_printf(m, "number of frees: %8d\n", kma_frees); seq_printf(m, "number of callers: %8d\n", kma_callers); seq_printf(m, "lost callers: %8d\n", kma_lost_callers); seq_printf(m, "lost allocs: %8d\n", kma_lost_allocs); seq_printf(m, "unknown frees: %8d\n", kma_unknown_frees); #ifdef CONFIG_SLOB seq_printf(m, "slob total: %8d\n", slob_total); seq_printf(m, "slob allocated: %8d\n", slob_req); #endif seq_puts(m, "\n total slack net alloc/free caller\n"); } for (i = 0; i < MAX_CALLER_TABLE; i++) { if(kma_caller[i].caller) n--; if(n < 0) return (void *)(i+1); } return 0; }
static int fjes_dbg_status_show(struct seq_file *m, void *v) { struct fjes_adapter *adapter = m->private; struct fjes_hw *hw = &adapter->hw; int max_epid = hw->max_epid; int my_epid = hw->my_epid; int epidx; seq_puts(m, "EPID\tSTATUS SAME_ZONE CONNECTED\n"); for (epidx = 0; epidx < max_epid; epidx++) { if (epidx == my_epid) { seq_printf(m, "ep%d\t%-16c %-16c %-16c\n", epidx, '-', '-', '-'); } else { seq_printf(m, "ep%d\t%-16s %-16c %-16c\n", epidx, ep_status_string[fjes_hw_get_partner_ep_status(hw, epidx)], fjes_hw_epid_is_same_zone(hw, epidx) ? 'Y' : 'N', fjes_hw_epid_is_shared(hw->hw_info.share, epidx) ? 'Y' : 'N'); } } return 0; }
static int atalk_seq_route_show(struct seq_file *seq, void *v) { struct atalk_route *rt; if (v == SEQ_START_TOKEN) { seq_puts(seq, "Target Router Flags Dev\n"); goto out; } if (atrtr_default.dev) { rt = &atrtr_default; seq_printf(seq, "Default %04X:%02X %-4d %s\n", ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags, rt->dev->name); } rt = v; seq_printf(seq, "%04X:%02X %04X:%02X %-4d %s\n", ntohs(rt->target.s_net), rt->target.s_node, ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags, rt->dev->name); out: return 0; }
int show_interrupts(struct seq_file *p, void *v) { struct irqaction *ap; int irq = *((loff_t *) v); if (irq == 0) seq_puts(p, " CPU0\n"); if (irq < NR_IRQS) { ap = irq_desc[irq].action; if (ap) { seq_printf(p, "%3d: ", irq); seq_printf(p, "%10u ", kstat_irqs(irq)); seq_printf(p, "%14s ", irq_desc[irq].chip->name); seq_printf(p, "%s", ap->name); for (ap = ap->next; ap; ap = ap->next) seq_printf(p, ", %s", ap->name); seq_putc(p, '\n'); } } return 0; }
static int vlan_seq_show(struct seq_file *seq, void *v) { struct net *net = seq_file_net(seq); struct vlan_net *vn = net_generic(net, vlan_net_id); if (v == SEQ_START_TOKEN) { const char *nmtype = NULL; seq_puts(seq, "VLAN Dev name | VLAN ID\n"); if (vn->name_type < ARRAY_SIZE(vlan_name_type_str)) nmtype = vlan_name_type_str[vn->name_type]; seq_printf(seq, "Name-Type: %s\n", nmtype ? nmtype : "UNKNOWN"); } else { const struct net_device *vlandev = v; const struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev); seq_printf(seq, "%-15s| %d | %s\n", vlandev->name, vlan->vlan_id, vlan->real_dev->name); } return 0; }