[S390] seq_file: convert drivers/s390/
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com> Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com> Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
This commit is contained in:
Alexey Dobriyan
Martin Schwidefsky
parent
618708ff04
commit
34b9243a30
|
|
@ -165,51 +165,32 @@ static const struct file_operations dasd_devices_file_ops = {
|
|||
.release = seq_release,
|
||||
};
|
||||
|
||||
static int
|
||||
dasd_calc_metrics(char *page, char **start, off_t off,
|
||||
int count, int *eof, int len)
|
||||
{
|
||||
len = (len > off) ? len - off : 0;
|
||||
if (len > count)
|
||||
len = count;
|
||||
if (len < count)
|
||||
*eof = 1;
|
||||
*start = page + off;
|
||||
return len;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_DASD_PROFILE
|
||||
static char *
|
||||
dasd_statistics_array(char *str, unsigned int *array, int factor)
|
||||
static void dasd_statistics_array(struct seq_file *m, unsigned int *array, int factor)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 32; i++) {
|
||||
str += sprintf(str, "%7d ", array[i] / factor);
|
||||
seq_printf(m, "%7d ", array[i] / factor);
|
||||
if (i == 15)
|
||||
str += sprintf(str, "\n");
|
||||
seq_putc(m, '\n');
|
||||
}
|
||||
str += sprintf(str,"\n");
|
||||
return str;
|
||||
seq_putc(m, '\n');
|
||||
}
|
||||
#endif /* CONFIG_DASD_PROFILE */
|
||||
|
||||
static int
|
||||
dasd_statistics_read(char *page, char **start, off_t off,
|
||||
int count, int *eof, void *data)
|
||||
static int dasd_stats_proc_show(struct seq_file *m, void *v)
|
||||
{
|
||||
unsigned long len;
|
||||
#ifdef CONFIG_DASD_PROFILE
|
||||
struct dasd_profile_info_t *prof;
|
||||
char *str;
|
||||
int factor;
|
||||
|
||||
/* check for active profiling */
|
||||
if (dasd_profile_level == DASD_PROFILE_OFF) {
|
||||
len = sprintf(page, "Statistics are off - they might be "
|
||||
seq_printf(m, "Statistics are off - they might be "
|
||||
"switched on using 'echo set on > "
|
||||
"/proc/dasd/statistics'\n");
|
||||
return dasd_calc_metrics(page, start, off, count, eof, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
prof = &dasd_global_profile;
|
||||
|
|
@ -217,47 +198,49 @@ dasd_statistics_read(char *page, char **start, off_t off,
|
|||
for (factor = 1; (prof->dasd_io_reqs / factor) > 9999999;
|
||||
factor *= 10);
|
||||
|
||||
str = page;
|
||||
str += sprintf(str, "%d dasd I/O requests\n", prof->dasd_io_reqs);
|
||||
str += sprintf(str, "with %u sectors(512B each)\n",
|
||||
seq_printf(m, "%d dasd I/O requests\n", prof->dasd_io_reqs);
|
||||
seq_printf(m, "with %u sectors(512B each)\n",
|
||||
prof->dasd_io_sects);
|
||||
str += sprintf(str, "Scale Factor is %d\n", factor);
|
||||
str += sprintf(str,
|
||||
seq_printf(m, "Scale Factor is %d\n", factor);
|
||||
seq_printf(m,
|
||||
" __<4 ___8 __16 __32 __64 _128 "
|
||||
" _256 _512 __1k __2k __4k __8k "
|
||||
" _16k _32k _64k 128k\n");
|
||||
str += sprintf(str,
|
||||
seq_printf(m,
|
||||
" _256 _512 __1M __2M __4M __8M "
|
||||
" _16M _32M _64M 128M 256M 512M "
|
||||
" __1G __2G __4G " " _>4G\n");
|
||||
|
||||
str += sprintf(str, "Histogram of sizes (512B secs)\n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_secs, factor);
|
||||
str += sprintf(str, "Histogram of I/O times (microseconds)\n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_times, factor);
|
||||
str += sprintf(str, "Histogram of I/O times per sector\n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_timps, factor);
|
||||
str += sprintf(str, "Histogram of I/O time till ssch\n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_time1, factor);
|
||||
str += sprintf(str, "Histogram of I/O time between ssch and irq\n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_time2, factor);
|
||||
str += sprintf(str, "Histogram of I/O time between ssch "
|
||||
seq_printf(m, "Histogram of sizes (512B secs)\n");
|
||||
dasd_statistics_array(m, prof->dasd_io_secs, factor);
|
||||
seq_printf(m, "Histogram of I/O times (microseconds)\n");
|
||||
dasd_statistics_array(m, prof->dasd_io_times, factor);
|
||||
seq_printf(m, "Histogram of I/O times per sector\n");
|
||||
dasd_statistics_array(m, prof->dasd_io_timps, factor);
|
||||
seq_printf(m, "Histogram of I/O time till ssch\n");
|
||||
dasd_statistics_array(m, prof->dasd_io_time1, factor);
|
||||
seq_printf(m, "Histogram of I/O time between ssch and irq\n");
|
||||
dasd_statistics_array(m, prof->dasd_io_time2, factor);
|
||||
seq_printf(m, "Histogram of I/O time between ssch "
|
||||
"and irq per sector\n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_time2ps, factor);
|
||||
str += sprintf(str, "Histogram of I/O time between irq and end\n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_time3, factor);
|
||||
str += sprintf(str, "# of req in chanq at enqueuing (1..32) \n");
|
||||
str = dasd_statistics_array(str, prof->dasd_io_nr_req, factor);
|
||||
len = str - page;
|
||||
dasd_statistics_array(m, prof->dasd_io_time2ps, factor);
|
||||
seq_printf(m, "Histogram of I/O time between irq and end\n");
|
||||
dasd_statistics_array(m, prof->dasd_io_time3, factor);
|
||||
seq_printf(m, "# of req in chanq at enqueuing (1..32) \n");
|
||||
dasd_statistics_array(m, prof->dasd_io_nr_req, factor);
|
||||
#else
|
||||
len = sprintf(page, "Statistics are not activated in this kernel\n");
|
||||
seq_printf(m, "Statistics are not activated in this kernel\n");
|
||||
#endif
|
||||
return dasd_calc_metrics(page, start, off, count, eof, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
dasd_statistics_write(struct file *file, const char __user *user_buf,
|
||||
unsigned long user_len, void *data)
|
||||
static int dasd_stats_proc_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
return single_open(file, dasd_stats_proc_show, NULL);
|
||||
}
|
||||
|
||||
static ssize_t dasd_stats_proc_write(struct file *file,
|
||||
const char __user *user_buf, size_t user_len, loff_t *pos)
|
||||
{
|
||||
#ifdef CONFIG_DASD_PROFILE
|
||||
char *buffer, *str;
|
||||
|
|
@ -308,6 +291,15 @@ out_error:
|
|||
#endif /* CONFIG_DASD_PROFILE */
|
||||
}
|
||||
|
||||
static const struct file_operations dasd_stats_proc_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = dasd_stats_proc_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = single_release,
|
||||
.write = dasd_stats_proc_write,
|
||||
};
|
||||
|
||||
/*
|
||||
* Create dasd proc-fs entries.
|
||||
* In case creation failed, cleanup and return -ENOENT.
|
||||
|
|
@ -324,13 +316,12 @@ dasd_proc_init(void)
|
|||
&dasd_devices_file_ops);
|
||||
if (!dasd_devices_entry)
|
||||
goto out_nodevices;
|
||||
dasd_statistics_entry = create_proc_entry("statistics",
|
||||
S_IFREG | S_IRUGO | S_IWUSR,
|
||||
dasd_proc_root_entry);
|
||||
dasd_statistics_entry = proc_create("statistics",
|
||||
S_IFREG | S_IRUGO | S_IWUSR,
|
||||
dasd_proc_root_entry,
|
||||
&dasd_stats_proc_fops);
|
||||
if (!dasd_statistics_entry)
|
||||
goto out_nostatistics;
|
||||
dasd_statistics_entry->read_proc = dasd_statistics_read;
|
||||
dasd_statistics_entry->write_proc = dasd_statistics_write;
|
||||
return 0;
|
||||
|
||||
out_nostatistics:
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@
|
|||
#include <linux/miscdevice.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/compat.h>
|
||||
#include <linux/smp_lock.h>
|
||||
#include <asm/atomic.h>
|
||||
|
|
@ -912,126 +913,105 @@ static struct miscdevice zcrypt_misc_device = {
|
|||
*/
|
||||
static struct proc_dir_entry *zcrypt_entry;
|
||||
|
||||
static int sprintcl(unsigned char *outaddr, unsigned char *addr,
|
||||
unsigned int len)
|
||||
static void sprintcl(struct seq_file *m, unsigned char *addr, unsigned int len)
|
||||
{
|
||||
int hl, i;
|
||||
int i;
|
||||
|
||||
hl = 0;
|
||||
for (i = 0; i < len; i++)
|
||||
hl += sprintf(outaddr+hl, "%01x", (unsigned int) addr[i]);
|
||||
hl += sprintf(outaddr+hl, " ");
|
||||
return hl;
|
||||
seq_printf(m, "%01x", (unsigned int) addr[i]);
|
||||
seq_putc(m, ' ');
|
||||
}
|
||||
|
||||
static int sprintrw(unsigned char *outaddr, unsigned char *addr,
|
||||
unsigned int len)
|
||||
static void sprintrw(struct seq_file *m, unsigned char *addr, unsigned int len)
|
||||
{
|
||||
int hl, inl, c, cx;
|
||||
int inl, c, cx;
|
||||
|
||||
hl = sprintf(outaddr, " ");
|
||||
seq_printf(m, " ");
|
||||
inl = 0;
|
||||
for (c = 0; c < (len / 16); c++) {
|
||||
hl += sprintcl(outaddr+hl, addr+inl, 16);
|
||||
sprintcl(m, addr+inl, 16);
|
||||
inl += 16;
|
||||
}
|
||||
cx = len%16;
|
||||
if (cx) {
|
||||
hl += sprintcl(outaddr+hl, addr+inl, cx);
|
||||
sprintcl(m, addr+inl, cx);
|
||||
inl += cx;
|
||||
}
|
||||
hl += sprintf(outaddr+hl, "\n");
|
||||
return hl;
|
||||
seq_putc(m, '\n');
|
||||
}
|
||||
|
||||
static int sprinthx(unsigned char *title, unsigned char *outaddr,
|
||||
unsigned char *addr, unsigned int len)
|
||||
static void sprinthx(unsigned char *title, struct seq_file *m,
|
||||
unsigned char *addr, unsigned int len)
|
||||
{
|
||||
int hl, inl, r, rx;
|
||||
int inl, r, rx;
|
||||
|
||||
hl = sprintf(outaddr, "\n%s\n", title);
|
||||
seq_printf(m, "\n%s\n", title);
|
||||
inl = 0;
|
||||
for (r = 0; r < (len / 64); r++) {
|
||||
hl += sprintrw(outaddr+hl, addr+inl, 64);
|
||||
sprintrw(m, addr+inl, 64);
|
||||
inl += 64;
|
||||
}
|
||||
rx = len % 64;
|
||||
if (rx) {
|
||||
hl += sprintrw(outaddr+hl, addr+inl, rx);
|
||||
sprintrw(m, addr+inl, rx);
|
||||
inl += rx;
|
||||
}
|
||||
hl += sprintf(outaddr+hl, "\n");
|
||||
return hl;
|
||||
seq_putc(m, '\n');
|
||||
}
|
||||
|
||||
static int sprinthx4(unsigned char *title, unsigned char *outaddr,
|
||||
unsigned int *array, unsigned int len)
|
||||
static void sprinthx4(unsigned char *title, struct seq_file *m,
|
||||
unsigned int *array, unsigned int len)
|
||||
{
|
||||
int hl, r;
|
||||
int r;
|
||||
|
||||
hl = sprintf(outaddr, "\n%s\n", title);
|
||||
seq_printf(m, "\n%s\n", title);
|
||||
for (r = 0; r < len; r++) {
|
||||
if ((r % 8) == 0)
|
||||
hl += sprintf(outaddr+hl, " ");
|
||||
hl += sprintf(outaddr+hl, "%08X ", array[r]);
|
||||
seq_printf(m, " ");
|
||||
seq_printf(m, "%08X ", array[r]);
|
||||
if ((r % 8) == 7)
|
||||
hl += sprintf(outaddr+hl, "\n");
|
||||
seq_putc(m, '\n');
|
||||
}
|
||||
hl += sprintf(outaddr+hl, "\n");
|
||||
return hl;
|
||||
seq_putc(m, '\n');
|
||||
}
|
||||
|
||||
static int zcrypt_status_read(char *resp_buff, char **start, off_t offset,
|
||||
int count, int *eof, void *data)
|
||||
static int zcrypt_proc_show(struct seq_file *m, void *v)
|
||||
{
|
||||
unsigned char *workarea;
|
||||
int len;
|
||||
char workarea[sizeof(int) * AP_DEVICES];
|
||||
|
||||
len = 0;
|
||||
|
||||
/* resp_buff is a page. Use the right half for a work area */
|
||||
workarea = resp_buff + 2000;
|
||||
len += sprintf(resp_buff + len, "\nzcrypt version: %d.%d.%d\n",
|
||||
ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
|
||||
len += sprintf(resp_buff + len, "Cryptographic domain: %d\n",
|
||||
ap_domain_index);
|
||||
len += sprintf(resp_buff + len, "Total device count: %d\n",
|
||||
zcrypt_device_count);
|
||||
len += sprintf(resp_buff + len, "PCICA count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_PCICA));
|
||||
len += sprintf(resp_buff + len, "PCICC count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_PCICC));
|
||||
len += sprintf(resp_buff + len, "PCIXCC MCL2 count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
|
||||
len += sprintf(resp_buff + len, "PCIXCC MCL3 count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
|
||||
len += sprintf(resp_buff + len, "CEX2C count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_CEX2C));
|
||||
len += sprintf(resp_buff + len, "CEX2A count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_CEX2A));
|
||||
len += sprintf(resp_buff + len, "CEX3C count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_CEX3C));
|
||||
len += sprintf(resp_buff + len, "CEX3A count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_CEX3A));
|
||||
len += sprintf(resp_buff + len, "requestq count: %d\n",
|
||||
zcrypt_requestq_count());
|
||||
len += sprintf(resp_buff + len, "pendingq count: %d\n",
|
||||
zcrypt_pendingq_count());
|
||||
len += sprintf(resp_buff + len, "Total open handles: %d\n\n",
|
||||
atomic_read(&zcrypt_open_count));
|
||||
seq_printf(m, "\nzcrypt version: %d.%d.%d\n",
|
||||
ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
|
||||
seq_printf(m, "Cryptographic domain: %d\n", ap_domain_index);
|
||||
seq_printf(m, "Total device count: %d\n", zcrypt_device_count);
|
||||
seq_printf(m, "PCICA count: %d\n", zcrypt_count_type(ZCRYPT_PCICA));
|
||||
seq_printf(m, "PCICC count: %d\n", zcrypt_count_type(ZCRYPT_PCICC));
|
||||
seq_printf(m, "PCIXCC MCL2 count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
|
||||
seq_printf(m, "PCIXCC MCL3 count: %d\n",
|
||||
zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
|
||||
seq_printf(m, "CEX2C count: %d\n", zcrypt_count_type(ZCRYPT_CEX2C));
|
||||
seq_printf(m, "CEX2A count: %d\n", zcrypt_count_type(ZCRYPT_CEX2A));
|
||||
seq_printf(m, "CEX3C count: %d\n", zcrypt_count_type(ZCRYPT_CEX3C));
|
||||
seq_printf(m, "CEX3A count: %d\n", zcrypt_count_type(ZCRYPT_CEX3A));
|
||||
seq_printf(m, "requestq count: %d\n", zcrypt_requestq_count());
|
||||
seq_printf(m, "pendingq count: %d\n", zcrypt_pendingq_count());
|
||||
seq_printf(m, "Total open handles: %d\n\n",
|
||||
atomic_read(&zcrypt_open_count));
|
||||
zcrypt_status_mask(workarea);
|
||||
len += sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
|
||||
"4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A 7=CEX3C 8=CEX3A",
|
||||
resp_buff+len, workarea, AP_DEVICES);
|
||||
sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
|
||||
"4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A 7=CEX3C 8=CEX3A",
|
||||
m, workarea, AP_DEVICES);
|
||||
zcrypt_qdepth_mask(workarea);
|
||||
len += sprinthx("Waiting work element counts",
|
||||
resp_buff+len, workarea, AP_DEVICES);
|
||||
sprinthx("Waiting work element counts", m, workarea, AP_DEVICES);
|
||||
zcrypt_perdev_reqcnt((int *) workarea);
|
||||
len += sprinthx4("Per-device successfully completed request counts",
|
||||
resp_buff+len,(unsigned int *) workarea, AP_DEVICES);
|
||||
*eof = 1;
|
||||
memset((void *) workarea, 0x00, AP_DEVICES * sizeof(unsigned int));
|
||||
return len;
|
||||
sprinthx4("Per-device successfully completed request counts",
|
||||
m, (unsigned int *) workarea, AP_DEVICES);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int zcrypt_proc_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
return single_open(file, zcrypt_proc_show, NULL);
|
||||
}
|
||||
|
||||
static void zcrypt_disable_card(int index)
|
||||
|
|
@ -1061,11 +1041,11 @@ static void zcrypt_enable_card(int index)
|
|||
spin_unlock_bh(&zcrypt_device_lock);
|
||||
}
|
||||
|
||||
static int zcrypt_status_write(struct file *file, const char __user *buffer,
|
||||
unsigned long count, void *data)
|
||||
static ssize_t zcrypt_proc_write(struct file *file, const char __user *buffer,
|
||||
size_t count, loff_t *pos)
|
||||
{
|
||||
unsigned char *lbuf, *ptr;
|
||||
unsigned long local_count;
|
||||
size_t local_count;
|
||||
int j;
|
||||
|
||||
if (count <= 0)
|
||||
|
|
@ -1115,6 +1095,15 @@ out:
|
|||
return count;
|
||||
}
|
||||
|
||||
static const struct file_operations zcrypt_proc_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = zcrypt_proc_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = single_release,
|
||||
.write = zcrypt_proc_write,
|
||||
};
|
||||
|
||||
static int zcrypt_rng_device_count;
|
||||
static u32 *zcrypt_rng_buffer;
|
||||
static int zcrypt_rng_buffer_index;
|
||||
|
|
@ -1197,14 +1186,11 @@ int __init zcrypt_api_init(void)
|
|||
goto out;
|
||||
|
||||
/* Set up the proc file system */
|
||||
zcrypt_entry = create_proc_entry("driver/z90crypt", 0644, NULL);
|
||||
zcrypt_entry = proc_create("driver/z90crypt", 0644, NULL, &zcrypt_proc_fops);
|
||||
if (!zcrypt_entry) {
|
||||
rc = -ENOMEM;
|
||||
goto out_misc;
|
||||
}
|
||||
zcrypt_entry->data = NULL;
|
||||
zcrypt_entry->read_proc = zcrypt_status_read;
|
||||
zcrypt_entry->write_proc = zcrypt_status_write;
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue