1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/sched.h>
15#include <linux/slab.h>
16#include <linux/fs.h>
17#include <linux/proc_fs.h>
18#include <linux/seq_file.h>
19#include <asm/errno.h>
20#include "internal.h"
21
22#ifdef CONFIG_KEYS_DEBUG_PROC_KEYS
23static int proc_keys_open(struct inode *inode, struct file *file);
24static void *proc_keys_start(struct seq_file *p, loff_t *_pos);
25static void *proc_keys_next(struct seq_file *p, void *v, loff_t *_pos);
26static void proc_keys_stop(struct seq_file *p, void *v);
27static int proc_keys_show(struct seq_file *m, void *v);
28
29static const struct seq_operations proc_keys_ops = {
30 .start = proc_keys_start,
31 .next = proc_keys_next,
32 .stop = proc_keys_stop,
33 .show = proc_keys_show,
34};
35
36static const struct file_operations proc_keys_fops = {
37 .open = proc_keys_open,
38 .read = seq_read,
39 .llseek = seq_lseek,
40 .release = seq_release,
41};
42#endif
43
44static int proc_key_users_open(struct inode *inode, struct file *file);
45static void *proc_key_users_start(struct seq_file *p, loff_t *_pos);
46static void *proc_key_users_next(struct seq_file *p, void *v, loff_t *_pos);
47static void proc_key_users_stop(struct seq_file *p, void *v);
48static int proc_key_users_show(struct seq_file *m, void *v);
49
50static const struct seq_operations proc_key_users_ops = {
51 .start = proc_key_users_start,
52 .next = proc_key_users_next,
53 .stop = proc_key_users_stop,
54 .show = proc_key_users_show,
55};
56
57static const struct file_operations proc_key_users_fops = {
58 .open = proc_key_users_open,
59 .read = seq_read,
60 .llseek = seq_lseek,
61 .release = seq_release,
62};
63
64
65
66
67
68static int __init key_proc_init(void)
69{
70 struct proc_dir_entry *p;
71
72#ifdef CONFIG_KEYS_DEBUG_PROC_KEYS
73 p = proc_create("keys", 0, NULL, &proc_keys_fops);
74 if (!p)
75 panic("Cannot create /proc/keys\n");
76#endif
77
78 p = proc_create("key-users", 0, NULL, &proc_key_users_fops);
79 if (!p)
80 panic("Cannot create /proc/key-users\n");
81
82 return 0;
83
84}
85
86__initcall(key_proc_init);
87
88
89
90
91
92#ifdef CONFIG_KEYS_DEBUG_PROC_KEYS
93
94static struct rb_node *key_serial_next(struct rb_node *n)
95{
96 struct user_namespace *user_ns = current_user_ns();
97
98 n = rb_next(n);
99 while (n) {
100 struct key *key = rb_entry(n, struct key, serial_node);
101 if (key->user->user_ns == user_ns)
102 break;
103 n = rb_next(n);
104 }
105 return n;
106}
107
108static int proc_keys_open(struct inode *inode, struct file *file)
109{
110 return seq_open(file, &proc_keys_ops);
111}
112
113static struct key *find_ge_key(key_serial_t id)
114{
115 struct user_namespace *user_ns = current_user_ns();
116 struct rb_node *n = key_serial_tree.rb_node;
117 struct key *minkey = NULL;
118
119 while (n) {
120 struct key *key = rb_entry(n, struct key, serial_node);
121 if (id < key->serial) {
122 if (!minkey || minkey->serial > key->serial)
123 minkey = key;
124 n = n->rb_left;
125 } else if (id > key->serial) {
126 n = n->rb_right;
127 } else {
128 minkey = key;
129 break;
130 }
131 key = NULL;
132 }
133
134 if (!minkey)
135 return NULL;
136
137 for (;;) {
138 if (minkey->user->user_ns == user_ns)
139 return minkey;
140 n = rb_next(&minkey->serial_node);
141 if (!n)
142 return NULL;
143 minkey = rb_entry(n, struct key, serial_node);
144 }
145}
146
147static void *proc_keys_start(struct seq_file *p, loff_t *_pos)
148 __acquires(key_serial_lock)
149{
150 key_serial_t pos = *_pos;
151 struct key *key;
152
153 spin_lock(&key_serial_lock);
154
155 if (*_pos > INT_MAX)
156 return NULL;
157 key = find_ge_key(pos);
158 if (!key)
159 return NULL;
160 *_pos = key->serial;
161 return &key->serial_node;
162}
163
164static inline key_serial_t key_node_serial(struct rb_node *n)
165{
166 struct key *key = rb_entry(n, struct key, serial_node);
167 return key->serial;
168}
169
170static void *proc_keys_next(struct seq_file *p, void *v, loff_t *_pos)
171{
172 struct rb_node *n;
173
174 n = key_serial_next(v);
175 if (n)
176 *_pos = key_node_serial(n);
177 return n;
178}
179
180static void proc_keys_stop(struct seq_file *p, void *v)
181 __releases(key_serial_lock)
182{
183 spin_unlock(&key_serial_lock);
184}
185
186static int proc_keys_show(struct seq_file *m, void *v)
187{
188 struct rb_node *_p = v;
189 struct key *key = rb_entry(_p, struct key, serial_node);
190 struct timespec now;
191 unsigned long timo;
192 char xbuf[12];
193 int rc;
194
195
196
197
198
199
200 rc = key_task_permission(make_key_ref(key, 0), current_cred(),
201 KEY_VIEW);
202 if (rc < 0)
203 return 0;
204
205 now = current_kernel_time();
206
207 rcu_read_lock();
208
209
210 if (key->expiry == 0) {
211 memcpy(xbuf, "perm", 5);
212 } else if (now.tv_sec >= key->expiry) {
213 memcpy(xbuf, "expd", 5);
214 } else {
215 timo = key->expiry - now.tv_sec;
216
217 if (timo < 60)
218 sprintf(xbuf, "%lus", timo);
219 else if (timo < 60*60)
220 sprintf(xbuf, "%lum", timo / 60);
221 else if (timo < 60*60*24)
222 sprintf(xbuf, "%luh", timo / (60*60));
223 else if (timo < 60*60*24*7)
224 sprintf(xbuf, "%lud", timo / (60*60*24));
225 else
226 sprintf(xbuf, "%luw", timo / (60*60*24*7));
227 }
228
229#define showflag(KEY, LETTER, FLAG) \
230 (test_bit(FLAG, &(KEY)->flags) ? LETTER : '-')
231
232 seq_printf(m, "%08x %c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ",
233 key->serial,
234 showflag(key, 'I', KEY_FLAG_INSTANTIATED),
235 showflag(key, 'R', KEY_FLAG_REVOKED),
236 showflag(key, 'D', KEY_FLAG_DEAD),
237 showflag(key, 'Q', KEY_FLAG_IN_QUOTA),
238 showflag(key, 'U', KEY_FLAG_USER_CONSTRUCT),
239 showflag(key, 'N', KEY_FLAG_NEGATIVE),
240 atomic_read(&key->usage),
241 xbuf,
242 key->perm,
243 key->uid,
244 key->gid,
245 key->type->name);
246
247#undef showflag
248
249 if (key->type->describe)
250 key->type->describe(key, m);
251 seq_putc(m, '\n');
252
253 rcu_read_unlock();
254 return 0;
255}
256
257#endif
258
259static struct rb_node *__key_user_next(struct rb_node *n)
260{
261 while (n) {
262 struct key_user *user = rb_entry(n, struct key_user, node);
263 if (user->user_ns == current_user_ns())
264 break;
265 n = rb_next(n);
266 }
267 return n;
268}
269
270static struct rb_node *key_user_next(struct rb_node *n)
271{
272 return __key_user_next(rb_next(n));
273}
274
275static struct rb_node *key_user_first(struct rb_root *r)
276{
277 struct rb_node *n = rb_first(r);
278 return __key_user_next(n);
279}
280
281
282
283
284
285static int proc_key_users_open(struct inode *inode, struct file *file)
286{
287 return seq_open(file, &proc_key_users_ops);
288}
289
290static void *proc_key_users_start(struct seq_file *p, loff_t *_pos)
291 __acquires(key_user_lock)
292{
293 struct rb_node *_p;
294 loff_t pos = *_pos;
295
296 spin_lock(&key_user_lock);
297
298 _p = key_user_first(&key_user_tree);
299 while (pos > 0 && _p) {
300 pos--;
301 _p = key_user_next(_p);
302 }
303
304 return _p;
305}
306
307static void *proc_key_users_next(struct seq_file *p, void *v, loff_t *_pos)
308{
309 (*_pos)++;
310 return key_user_next((struct rb_node *) v);
311}
312
313static void proc_key_users_stop(struct seq_file *p, void *v)
314 __releases(key_user_lock)
315{
316 spin_unlock(&key_user_lock);
317}
318
319static int proc_key_users_show(struct seq_file *m, void *v)
320{
321 struct rb_node *_p = v;
322 struct key_user *user = rb_entry(_p, struct key_user, node);
323 unsigned maxkeys = (user->uid == 0) ?
324 key_quota_root_maxkeys : key_quota_maxkeys;
325 unsigned maxbytes = (user->uid == 0) ?
326 key_quota_root_maxbytes : key_quota_maxbytes;
327
328 seq_printf(m, "%5u: %5d %d/%d %d/%d %d/%d\n",
329 user->uid,
330 atomic_read(&user->usage),
331 atomic_read(&user->nkeys),
332 atomic_read(&user->nikeys),
333 user->qnkeys,
334 maxkeys,
335 user->qnbytes,
336 maxbytes);
337
338 return 0;
339
340}
341
