Merge git://git.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6
[linux-2.6] / drivers / s390 / char / tape_proc.c
1 /*
2  *  drivers/s390/char/tape.c
3  *    tape device driver for S/390 and zSeries tapes.
4  *
5  *  S390 and zSeries version
6  *    Copyright (C) 2001 IBM Corporation
7  *    Author(s): Carsten Otte <cotte@de.ibm.com>
8  *               Michael Holzheu <holzheu@de.ibm.com>
9  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
10  *
11  * PROCFS Functions
12  */
13
14 #include <linux/module.h>
15 #include <linux/vmalloc.h>
16 #include <linux/seq_file.h>
17 #include <linux/proc_fs.h>
18
19 #define TAPE_DBF_AREA   tape_core_dbf
20
21 #include "tape.h"
22
23 #define PRINTK_HEADER "TAPE_PROC: "
24
25 static const char *tape_med_st_verbose[MS_SIZE] =
26 {
27         [MS_UNKNOWN] = "UNKNOWN ",
28         [MS_LOADED] = "LOADED  ",
29         [MS_UNLOADED] = "UNLOADED"
30 };
31
32 /* our proc tapedevices entry */
33 static struct proc_dir_entry *tape_proc_devices;
34
35 /*
36  * Show function for /proc/tapedevices
37  */
38 static int tape_proc_show(struct seq_file *m, void *v)
39 {
40         struct tape_device *device;
41         struct tape_request *request;
42         const char *str;
43         unsigned long n;
44
45         n = (unsigned long) v - 1;
46         if (!n) {
47                 seq_printf(m, "TapeNo\tBusID      CuType/Model\t"
48                         "DevType/Model\tBlkSize\tState\tOp\tMedState\n");
49         }
50         device = tape_get_device(n);
51         if (IS_ERR(device))
52                 return 0;
53         spin_lock_irq(get_ccwdev_lock(device->cdev));
54         seq_printf(m, "%d\t", (int) n);
55         seq_printf(m, "%-10.10s ", device->cdev->dev.bus_id);
56         seq_printf(m, "%04X/", device->cdev->id.cu_type);
57         seq_printf(m, "%02X\t", device->cdev->id.cu_model);
58         seq_printf(m, "%04X/", device->cdev->id.dev_type);
59         seq_printf(m, "%02X\t\t", device->cdev->id.dev_model);
60         if (device->char_data.block_size == 0)
61                 seq_printf(m, "auto\t");
62         else
63                 seq_printf(m, "%i\t", device->char_data.block_size);
64         if (device->tape_state >= 0 &&
65             device->tape_state < TS_SIZE)
66                 str = tape_state_verbose[device->tape_state];
67         else
68                 str = "UNKNOWN";
69         seq_printf(m, "%s\t", str);
70         if (!list_empty(&device->req_queue)) {
71                 request = list_entry(device->req_queue.next,
72                                      struct tape_request, list);
73                 str = tape_op_verbose[request->op];
74         } else
75                 str = "---";
76         seq_printf(m, "%s\t", str);
77         seq_printf(m, "%s\n", tape_med_st_verbose[device->medium_state]);
78         spin_unlock_irq(get_ccwdev_lock(device->cdev));
79         tape_put_device(device);
80         return 0;
81 }
82
83 static void *tape_proc_start(struct seq_file *m, loff_t *pos)
84 {
85         if (*pos >= 256 / TAPE_MINORS_PER_DEV)
86                 return NULL;
87         return (void *)((unsigned long) *pos + 1);
88 }
89
90 static void *tape_proc_next(struct seq_file *m, void *v, loff_t *pos)
91 {
92         ++*pos;
93         return tape_proc_start(m, pos);
94 }
95
96 static void tape_proc_stop(struct seq_file *m, void *v)
97 {
98 }
99
100 static const struct seq_operations tape_proc_seq = {
101         .start          = tape_proc_start,
102         .next           = tape_proc_next,
103         .stop           = tape_proc_stop,
104         .show           = tape_proc_show,
105 };
106
107 static int tape_proc_open(struct inode *inode, struct file *file)
108 {
109         return seq_open(file, &tape_proc_seq);
110 }
111
112 static const struct file_operations tape_proc_ops =
113 {
114         .open           = tape_proc_open,
115         .read           = seq_read,
116         .llseek         = seq_lseek,
117         .release        = seq_release,
118 };
119
120 /*
121  * Initialize procfs stuff on startup
122  */
123 void
124 tape_proc_init(void)
125 {
126         tape_proc_devices =
127                 create_proc_entry ("tapedevices", S_IFREG | S_IRUGO | S_IWUSR,
128                                    &proc_root);
129         if (tape_proc_devices == NULL) {
130                 PRINT_WARN("tape: Cannot register procfs entry tapedevices\n");
131                 return;
132         }
133         tape_proc_devices->proc_fops = &tape_proc_ops;
134         tape_proc_devices->owner = THIS_MODULE;
135 }
136
137 /*
138  * Cleanup all stuff registered to the procfs
139  */
140 void
141 tape_proc_cleanup(void)
142 {
143         if (tape_proc_devices != NULL)
144                 remove_proc_entry ("tapedevices", &proc_root);
145 }