Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Joe Perches | 9982446 | 2010-01-26 11:40:00 +0000 | [diff] [blame] | 2 | #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | |
| 4 | #ifdef CONFIG_PROC_FS |
| 5 | #include <linux/errno.h> |
| 6 | #include <linux/kernel.h> |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 7 | #include <linux/string.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | #include <linux/mm.h> |
| 9 | #include <linux/module.h> |
| 10 | #include <linux/proc_fs.h> |
| 11 | #include <linux/time.h> |
| 12 | #include <linux/seq_file.h> |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 13 | #include <linux/uaccess.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <linux/atmmpc.h> |
| 15 | #include <linux/atm.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 16 | #include <linux/gfp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include "mpc.h" |
| 18 | #include "mpoa_caches.h" |
| 19 | |
| 20 | /* |
| 21 | * mpoa_proc.c: Implementation MPOA client's proc |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 22 | * file system statistics |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | */ |
| 24 | |
| 25 | #if 1 |
Joe Perches | b50c2ea | 2010-01-26 11:40:20 +0000 | [diff] [blame] | 26 | #define dprintk(format, args...) \ |
| 27 | printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args) /* debug */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #else |
Joe Perches | b50c2ea | 2010-01-26 11:40:20 +0000 | [diff] [blame] | 29 | #define dprintk(format, args...) \ |
| 30 | do { if (0) \ |
| 31 | printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args);\ |
| 32 | } while (0) |
| 33 | #endif |
| 34 | |
| 35 | #if 0 |
| 36 | #define ddprintk(format, args...) \ |
| 37 | printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args) /* debug */ |
| 38 | #else |
| 39 | #define ddprintk(format, args...) \ |
| 40 | do { if (0) \ |
| 41 | printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args);\ |
| 42 | } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | #endif |
| 44 | |
| 45 | #define STAT_FILE_NAME "mpc" /* Our statistic file's name */ |
| 46 | |
| 47 | extern struct mpoa_client *mpcs; |
| 48 | extern struct proc_dir_entry *atm_proc_root; /* from proc.c. */ |
| 49 | |
| 50 | static int proc_mpc_open(struct inode *inode, struct file *file); |
| 51 | static ssize_t proc_mpc_write(struct file *file, const char __user *buff, |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 52 | size_t nbytes, loff_t *ppos); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | |
| 54 | static int parse_qos(const char *buff); |
| 55 | |
| 56 | /* |
| 57 | * Define allowed FILE OPERATIONS |
| 58 | */ |
Arjan van de Ven | 9a32144 | 2007-02-12 00:55:35 -0800 | [diff] [blame] | 59 | static const struct file_operations mpc_file_operations = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | .owner = THIS_MODULE, |
| 61 | .open = proc_mpc_open, |
| 62 | .read = seq_read, |
| 63 | .llseek = seq_lseek, |
| 64 | .write = proc_mpc_write, |
| 65 | .release = seq_release, |
| 66 | }; |
| 67 | |
| 68 | /* |
| 69 | * Returns the state of an ingress cache entry as a string |
| 70 | */ |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 71 | static const char *ingress_state_string(int state) |
| 72 | { |
| 73 | switch (state) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | case INGRESS_RESOLVING: |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 75 | return "resolving "; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | case INGRESS_RESOLVED: |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 77 | return "resolved "; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | case INGRESS_INVALID: |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 79 | return "invalid "; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | case INGRESS_REFRESHING: |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 81 | return "refreshing "; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | } |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 83 | |
| 84 | return ""; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | /* |
| 88 | * Returns the state of an egress cache entry as a string |
| 89 | */ |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 90 | static const char *egress_state_string(int state) |
| 91 | { |
| 92 | switch (state) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | case EGRESS_RESOLVED: |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 94 | return "resolved "; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | case EGRESS_PURGE: |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 96 | return "purge "; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | case EGRESS_INVALID: |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 98 | return "invalid "; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | } |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 100 | |
| 101 | return ""; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | /* |
| 105 | * FIXME: mpcs (and per-mpc lists) have no locking whatsoever. |
| 106 | */ |
| 107 | |
| 108 | static void *mpc_start(struct seq_file *m, loff_t *pos) |
| 109 | { |
| 110 | loff_t l = *pos; |
| 111 | struct mpoa_client *mpc; |
| 112 | |
| 113 | if (!l--) |
| 114 | return SEQ_START_TOKEN; |
| 115 | for (mpc = mpcs; mpc; mpc = mpc->next) |
| 116 | if (!l--) |
| 117 | return mpc; |
| 118 | return NULL; |
| 119 | } |
| 120 | |
| 121 | static void *mpc_next(struct seq_file *m, void *v, loff_t *pos) |
| 122 | { |
| 123 | struct mpoa_client *p = v; |
| 124 | (*pos)++; |
| 125 | return v == SEQ_START_TOKEN ? mpcs : p->next; |
| 126 | } |
| 127 | |
| 128 | static void mpc_stop(struct seq_file *m, void *v) |
| 129 | { |
| 130 | } |
| 131 | |
| 132 | /* |
| 133 | * READING function - called when the /proc/atm/mpoa file is read from. |
| 134 | */ |
| 135 | static int mpc_show(struct seq_file *m, void *v) |
| 136 | { |
| 137 | struct mpoa_client *mpc = v; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | int i; |
| 139 | in_cache_entry *in_entry; |
| 140 | eg_cache_entry *eg_entry; |
| 141 | struct timeval now; |
| 142 | unsigned char ip_string[16]; |
| 143 | |
| 144 | if (v == SEQ_START_TOKEN) { |
| 145 | atm_mpoa_disp_qos(m); |
| 146 | return 0; |
| 147 | } |
| 148 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 149 | seq_printf(m, "\nInterface %d:\n\n", mpc->dev_num); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | seq_printf(m, "Ingress Entries:\nIP address State Holding time Packets fwded VPI VCI\n"); |
| 151 | do_gettimeofday(&now); |
| 152 | |
| 153 | for (in_entry = mpc->in_cache; in_entry; in_entry = in_entry->next) { |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 154 | sprintf(ip_string, "%pI4", &in_entry->ctrl_info.in_dst_ip); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | seq_printf(m, "%-16s%s%-14lu%-12u", |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 156 | ip_string, |
| 157 | ingress_state_string(in_entry->entry_state), |
| 158 | in_entry->ctrl_info.holding_time - |
| 159 | (now.tv_sec-in_entry->tv.tv_sec), |
| 160 | in_entry->packets_fwded); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | if (in_entry->shortcut) |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 162 | seq_printf(m, " %-3d %-3d", |
| 163 | in_entry->shortcut->vpi, |
| 164 | in_entry->shortcut->vci); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | seq_printf(m, "\n"); |
| 166 | } |
| 167 | |
| 168 | seq_printf(m, "\n"); |
| 169 | seq_printf(m, "Egress Entries:\nIngress MPC ATM addr\nCache-id State Holding time Packets recvd Latest IP addr VPI VCI\n"); |
| 170 | for (eg_entry = mpc->eg_cache; eg_entry; eg_entry = eg_entry->next) { |
| 171 | unsigned char *p = eg_entry->ctrl_info.in_MPC_data_ATM_addr; |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 172 | for (i = 0; i < ATM_ESA_LEN; i++) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | seq_printf(m, "%02x", p[i]); |
| 174 | seq_printf(m, "\n%-16lu%s%-14lu%-15u", |
| 175 | (unsigned long)ntohl(eg_entry->ctrl_info.cache_id), |
| 176 | egress_state_string(eg_entry->entry_state), |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 177 | (eg_entry->ctrl_info.holding_time - |
| 178 | (now.tv_sec-eg_entry->tv.tv_sec)), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | eg_entry->packets_rcvd); |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 180 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | /* latest IP address */ |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 182 | sprintf(ip_string, "%pI4", &eg_entry->latest_ip_addr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | seq_printf(m, "%-16s", ip_string); |
| 184 | |
| 185 | if (eg_entry->shortcut) |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 186 | seq_printf(m, " %-3d %-3d", |
| 187 | eg_entry->shortcut->vpi, |
| 188 | eg_entry->shortcut->vci); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | seq_printf(m, "\n"); |
| 190 | } |
| 191 | seq_printf(m, "\n"); |
| 192 | return 0; |
| 193 | } |
| 194 | |
Philippe De Muyter | 56b3d97 | 2007-07-10 23:07:31 -0700 | [diff] [blame] | 195 | static const struct seq_operations mpc_op = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | .start = mpc_start, |
| 197 | .next = mpc_next, |
| 198 | .stop = mpc_stop, |
| 199 | .show = mpc_show |
| 200 | }; |
| 201 | |
| 202 | static int proc_mpc_open(struct inode *inode, struct file *file) |
| 203 | { |
| 204 | return seq_open(file, &mpc_op); |
| 205 | } |
| 206 | |
| 207 | static ssize_t proc_mpc_write(struct file *file, const char __user *buff, |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 208 | size_t nbytes, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | { |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 210 | char *page, *p; |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 211 | unsigned int len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 213 | if (nbytes == 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | return 0; |
| 215 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 216 | if (nbytes >= PAGE_SIZE) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | nbytes = PAGE_SIZE-1; |
| 218 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 219 | page = (char *)__get_free_page(GFP_KERNEL); |
| 220 | if (!page) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | return -ENOMEM; |
| 222 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 223 | for (p = page, len = 0; len < nbytes; p++, len++) { |
| 224 | if (get_user(*p, buff++)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | free_page((unsigned long)page); |
| 226 | return -EFAULT; |
| 227 | } |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 228 | if (*p == '\0' || *p == '\n') |
| 229 | break; |
| 230 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 232 | *p = '\0'; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | |
| 234 | if (!parse_qos(page)) |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 235 | printk("mpoa: proc_mpc_write: could not parse '%s'\n", page); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 237 | free_page((unsigned long)page); |
| 238 | |
| 239 | return len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | } |
| 241 | |
| 242 | static int parse_qos(const char *buff) |
| 243 | { |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 244 | /* possible lines look like this |
| 245 | * add 130.230.54.142 tx=max_pcr,max_sdu rx=max_pcr,max_sdu |
| 246 | */ |
| 247 | unsigned char ip[4]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | int tx_pcr, tx_sdu, rx_pcr, rx_sdu; |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 249 | __be32 ipaddr; |
| 250 | struct atm_qos qos; |
| 251 | |
| 252 | memset(&qos, 0, sizeof(struct atm_qos)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | |
| 254 | if (sscanf(buff, "del %hhu.%hhu.%hhu.%hhu", |
| 255 | ip, ip+1, ip+2, ip+3) == 4) { |
Al Viro | 30d492d | 2006-11-14 21:11:29 -0800 | [diff] [blame] | 256 | ipaddr = *(__be32 *)ip; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | return atm_mpoa_delete_qos(atm_mpoa_search_qos(ipaddr)); |
| 258 | } |
| 259 | |
| 260 | if (sscanf(buff, "add %hhu.%hhu.%hhu.%hhu tx=%d,%d rx=tx", |
| 261 | ip, ip+1, ip+2, ip+3, &tx_pcr, &tx_sdu) == 6) { |
| 262 | rx_pcr = tx_pcr; |
| 263 | rx_sdu = tx_sdu; |
| 264 | } else if (sscanf(buff, "add %hhu.%hhu.%hhu.%hhu tx=%d,%d rx=%d,%d", |
| 265 | ip, ip+1, ip+2, ip+3, &tx_pcr, &tx_sdu, &rx_pcr, &rx_sdu) != 8) |
| 266 | return 0; |
| 267 | |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 268 | ipaddr = *(__be32 *)ip; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | qos.txtp.traffic_class = ATM_CBR; |
| 270 | qos.txtp.max_pcr = tx_pcr; |
| 271 | qos.txtp.max_sdu = tx_sdu; |
| 272 | qos.rxtp.traffic_class = ATM_CBR; |
| 273 | qos.rxtp.max_pcr = rx_pcr; |
| 274 | qos.rxtp.max_sdu = rx_sdu; |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 275 | qos.aal = ATM_AAL5; |
Masanari Iida | f42cf8d | 2015-02-24 23:11:26 +0900 | [diff] [blame] | 276 | dprintk("parse_qos(): setting qos parameters to tx=%d,%d rx=%d,%d\n", |
Joe Perches | b50c2ea | 2010-01-26 11:40:20 +0000 | [diff] [blame] | 277 | qos.txtp.max_pcr, qos.txtp.max_sdu, |
| 278 | qos.rxtp.max_pcr, qos.rxtp.max_sdu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | |
| 280 | atm_mpoa_add_qos(ipaddr, &qos); |
| 281 | return 1; |
| 282 | } |
| 283 | |
| 284 | /* |
| 285 | * INITIALIZATION function - called when module is initialized/loaded. |
| 286 | */ |
| 287 | int mpc_proc_init(void) |
| 288 | { |
| 289 | struct proc_dir_entry *p; |
| 290 | |
Wang Chen | 16e297b | 2008-02-28 13:55:45 -0800 | [diff] [blame] | 291 | p = proc_create(STAT_FILE_NAME, 0, atm_proc_root, &mpc_file_operations); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | if (!p) { |
Joe Perches | 9982446 | 2010-01-26 11:40:00 +0000 | [diff] [blame] | 293 | pr_err("Unable to initialize /proc/atm/%s\n", STAT_FILE_NAME); |
YOSHIFUJI Hideaki | f7d5745 | 2007-02-09 23:24:29 +0900 | [diff] [blame] | 294 | return -ENOMEM; |
| 295 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | return 0; |
| 297 | } |
| 298 | |
| 299 | /* |
| 300 | * DELETING function - called when module is removed. |
| 301 | */ |
| 302 | void mpc_proc_clean(void) |
| 303 | { |
Joe Perches | f1e1004 | 2010-01-26 11:40:11 +0000 | [diff] [blame] | 304 | remove_proc_entry(STAT_FILE_NAME, atm_proc_root); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | } |
| 306 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | #endif /* CONFIG_PROC_FS */ |
| 308 | |
| 309 | |
| 310 | |
| 311 | |
| 312 | |
| 313 | |