1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43#include <linux/mm.h>
44#include <linux/shm.h>
45#include <linux/init.h>
46#include <linux/msg.h>
47#include <linux/vmalloc.h>
48#include <linux/slab.h>
49#include <linux/notifier.h>
50#include <linux/capability.h>
51#include <linux/highuid.h>
52#include <linux/security.h>
53#include <linux/rcupdate.h>
54#include <linux/workqueue.h>
55#include <linux/seq_file.h>
56#include <linux/proc_fs.h>
57#include <linux/audit.h>
58#include <linux/nsproxy.h>
59#include <linux/rwsem.h>
60#include <linux/memory.h>
61#include <linux/ipc_namespace.h>
62
63#include <asm/unistd.h>
64
65#include "util.h"
66
67struct ipc_proc_iface {
68 const char *path;
69 const char *header;
70 int ids;
71 int (*show)(struct seq_file *, void *);
72};
73
74
75
76
77
78
79
80
81
82
83
84static int __init ipc_init(void)
85{
86 sem_init();
87 msg_init();
88 shm_init();
89 return 0;
90}
91device_initcall(ipc_init);
92
93
94
95
96
97
98
99
100void ipc_init_ids(struct ipc_ids *ids)
101{
102 ids->in_use = 0;
103 ids->seq = 0;
104 ids->next_id = -1;
105 init_rwsem(&ids->rwsem);
106 idr_init(&ids->ipcs_idr);
107}
108
109#ifdef CONFIG_PROC_FS
110static const struct file_operations sysvipc_proc_fops;
111
112
113
114
115
116
117
118void __init ipc_init_proc_interface(const char *path, const char *header,
119 int ids, int (*show)(struct seq_file *, void *))
120{
121 struct proc_dir_entry *pde;
122 struct ipc_proc_iface *iface;
123
124 iface = kmalloc(sizeof(*iface), GFP_KERNEL);
125 if (!iface)
126 return;
127 iface->path = path;
128 iface->header = header;
129 iface->ids = ids;
130 iface->show = show;
131
132 pde = proc_create_data(path,
133 S_IRUGO,
134 NULL,
135 &sysvipc_proc_fops,
136 iface);
137 if (!pde)
138 kfree(iface);
139}
140#endif
141
142
143
144
145
146
147
148
149
150
151
152static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key)
153{
154 struct kern_ipc_perm *ipc;
155 int next_id;
156 int total;
157
158 for (total = 0, next_id = 0; total < ids->in_use; next_id++) {
159 ipc = idr_find(&ids->ipcs_idr, next_id);
160
161 if (ipc == NULL)
162 continue;
163
164 if (ipc->key != key) {
165 total++;
166 continue;
167 }
168
169 rcu_read_lock();
170 ipc_lock_object(ipc);
171 return ipc;
172 }
173
174 return NULL;
175}
176
177
178
179
180
181
182
183int ipc_get_maxid(struct ipc_ids *ids)
184{
185 struct kern_ipc_perm *ipc;
186 int max_id = -1;
187 int total, id;
188
189 if (ids->in_use == 0)
190 return -1;
191
192 if (ids->in_use == IPCMNI)
193 return IPCMNI - 1;
194
195
196 total = 0;
197 for (id = 0; id < IPCMNI && total < ids->in_use; id++) {
198 ipc = idr_find(&ids->ipcs_idr, id);
199 if (ipc != NULL) {
200 max_id = id;
201 total++;
202 }
203 }
204 return max_id;
205}
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int size)
221{
222 kuid_t euid;
223 kgid_t egid;
224 int id;
225 int next_id = ids->next_id;
226
227 if (size > IPCMNI)
228 size = IPCMNI;
229
230 if (ids->in_use >= size)
231 return -ENOSPC;
232
233 idr_preload(GFP_KERNEL);
234
235 atomic_set(&new->refcount, 1);
236 spin_lock_init(&new->lock);
237 new->deleted = false;
238 rcu_read_lock();
239 spin_lock(&new->lock);
240
241 current_euid_egid(&euid, &egid);
242 new->cuid = new->uid = euid;
243 new->gid = new->cgid = egid;
244
245 id = idr_alloc(&ids->ipcs_idr, new,
246 (next_id < 0) ? 0 : ipcid_to_idx(next_id), 0,
247 GFP_NOWAIT);
248 idr_preload_end();
249 if (id < 0) {
250 spin_unlock(&new->lock);
251 rcu_read_unlock();
252 return id;
253 }
254
255 ids->in_use++;
256
257 if (next_id < 0) {
258 new->seq = ids->seq++;
259 if (ids->seq > IPCID_SEQ_MAX)
260 ids->seq = 0;
261 } else {
262 new->seq = ipcid_to_seqx(next_id);
263 ids->next_id = -1;
264 }
265
266 new->id = ipc_buildid(id, new->seq);
267 return id;
268}
269
270
271
272
273
274
275
276
277
278
279
280static int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids,
281 const struct ipc_ops *ops, struct ipc_params *params)
282{
283 int err;
284
285 down_write(&ids->rwsem);
286 err = ops->getnew(ns, params);
287 up_write(&ids->rwsem);
288 return err;
289}
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306static int ipc_check_perms(struct ipc_namespace *ns,
307 struct kern_ipc_perm *ipcp,
308 const struct ipc_ops *ops,
309 struct ipc_params *params)
310{
311 int err;
312
313 if (ipcperms(ns, ipcp, params->flg))
314 err = -EACCES;
315 else {
316 err = ops->associate(ipcp, params->flg);
317 if (!err)
318 err = ipcp->id;
319 }
320
321 return err;
322}
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
339 const struct ipc_ops *ops, struct ipc_params *params)
340{
341 struct kern_ipc_perm *ipcp;
342 int flg = params->flg;
343 int err;
344
345
346
347
348
349 down_write(&ids->rwsem);
350 ipcp = ipc_findkey(ids, params->key);
351 if (ipcp == NULL) {
352
353 if (!(flg & IPC_CREAT))
354 err = -ENOENT;
355 else
356 err = ops->getnew(ns, params);
357 } else {
358
359
360 if (flg & IPC_CREAT && flg & IPC_EXCL)
361 err = -EEXIST;
362 else {
363 err = 0;
364 if (ops->more_checks)
365 err = ops->more_checks(ipcp, params);
366 if (!err)
367
368
369
370
371 err = ipc_check_perms(ns, ipcp, ops, params);
372 }
373 ipc_unlock(ipcp);
374 }
375 up_write(&ids->rwsem);
376
377 return err;
378}
379
380
381
382
383
384
385
386
387
388
389void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
390{
391 int lid = ipcid_to_idx(ipcp->id);
392
393 idr_remove(&ids->ipcs_idr, lid);
394 ids->in_use--;
395 ipcp->deleted = true;
396}
397
398int ipc_rcu_getref(struct kern_ipc_perm *ptr)
399{
400 return atomic_inc_not_zero(&ptr->refcount);
401}
402
403void ipc_rcu_putref(struct kern_ipc_perm *ptr,
404 void (*func)(struct rcu_head *head))
405{
406 if (!atomic_dec_and_test(&ptr->refcount))
407 return;
408
409 call_rcu(&ptr->rcu, func);
410}
411
412
413
414
415
416
417
418
419
420
421
422
423int ipcperms(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp, short flag)
424{
425 kuid_t euid = current_euid();
426 int requested_mode, granted_mode;
427
428 audit_ipc_obj(ipcp);
429 requested_mode = (flag >> 6) | (flag >> 3) | flag;
430 granted_mode = ipcp->mode;
431 if (uid_eq(euid, ipcp->cuid) ||
432 uid_eq(euid, ipcp->uid))
433 granted_mode >>= 6;
434 else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
435 granted_mode >>= 3;
436
437 if ((requested_mode & ~granted_mode & 0007) &&
438 !ns_capable(ns->user_ns, CAP_IPC_OWNER))
439 return -1;
440
441 return security_ipc_permission(ipcp, flag);
442}
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457void kernel_to_ipc64_perm(struct kern_ipc_perm *in, struct ipc64_perm *out)
458{
459 out->key = in->key;
460 out->uid = from_kuid_munged(current_user_ns(), in->uid);
461 out->gid = from_kgid_munged(current_user_ns(), in->gid);
462 out->cuid = from_kuid_munged(current_user_ns(), in->cuid);
463 out->cgid = from_kgid_munged(current_user_ns(), in->cgid);
464 out->mode = in->mode;
465 out->seq = in->seq;
466}
467
468
469
470
471
472
473
474
475
476void ipc64_perm_to_ipc_perm(struct ipc64_perm *in, struct ipc_perm *out)
477{
478 out->key = in->key;
479 SET_UID(out->uid, in->uid);
480 SET_GID(out->gid, in->gid);
481 SET_UID(out->cuid, in->cuid);
482 SET_GID(out->cgid, in->cgid);
483 out->mode = in->mode;
484 out->seq = in->seq;
485}
486
487
488
489
490
491
492
493
494
495
496
497struct kern_ipc_perm *ipc_obtain_object_idr(struct ipc_ids *ids, int id)
498{
499 struct kern_ipc_perm *out;
500 int lid = ipcid_to_idx(id);
501
502 out = idr_find(&ids->ipcs_idr, lid);
503 if (!out)
504 return ERR_PTR(-EINVAL);
505
506 return out;
507}
508
509
510
511
512
513
514
515
516
517
518struct kern_ipc_perm *ipc_lock(struct ipc_ids *ids, int id)
519{
520 struct kern_ipc_perm *out;
521
522 rcu_read_lock();
523 out = ipc_obtain_object_idr(ids, id);
524 if (IS_ERR(out))
525 goto err;
526
527 spin_lock(&out->lock);
528
529
530
531
532
533
534
535 if (ipc_valid_object(out))
536 return out;
537
538 spin_unlock(&out->lock);
539 out = ERR_PTR(-EIDRM);
540err:
541 rcu_read_unlock();
542 return out;
543}
544
545
546
547
548
549
550
551
552
553
554
555
556struct kern_ipc_perm *ipc_obtain_object_check(struct ipc_ids *ids, int id)
557{
558 struct kern_ipc_perm *out = ipc_obtain_object_idr(ids, id);
559
560 if (IS_ERR(out))
561 goto out;
562
563 if (ipc_checkid(out, id))
564 return ERR_PTR(-EINVAL);
565out:
566 return out;
567}
568
569
570
571
572
573
574
575
576
577
578
579int ipcget(struct ipc_namespace *ns, struct ipc_ids *ids,
580 const struct ipc_ops *ops, struct ipc_params *params)
581{
582 if (params->key == IPC_PRIVATE)
583 return ipcget_new(ns, ids, ops, params);
584 else
585 return ipcget_public(ns, ids, ops, params);
586}
587
588
589
590
591
592
593int ipc_update_perm(struct ipc64_perm *in, struct kern_ipc_perm *out)
594{
595 kuid_t uid = make_kuid(current_user_ns(), in->uid);
596 kgid_t gid = make_kgid(current_user_ns(), in->gid);
597 if (!uid_valid(uid) || !gid_valid(gid))
598 return -EINVAL;
599
600 out->uid = uid;
601 out->gid = gid;
602 out->mode = (out->mode & ~S_IRWXUGO)
603 | (in->mode & S_IRWXUGO);
604
605 return 0;
606}
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628struct kern_ipc_perm *ipcctl_pre_down_nolock(struct ipc_namespace *ns,
629 struct ipc_ids *ids, int id, int cmd,
630 struct ipc64_perm *perm, int extra_perm)
631{
632 kuid_t euid;
633 int err = -EPERM;
634 struct kern_ipc_perm *ipcp;
635
636 ipcp = ipc_obtain_object_check(ids, id);
637 if (IS_ERR(ipcp)) {
638 err = PTR_ERR(ipcp);
639 goto err;
640 }
641
642 audit_ipc_obj(ipcp);
643 if (cmd == IPC_SET)
644 audit_ipc_set_perm(extra_perm, perm->uid,
645 perm->gid, perm->mode);
646
647 euid = current_euid();
648 if (uid_eq(euid, ipcp->cuid) || uid_eq(euid, ipcp->uid) ||
649 ns_capable(ns->user_ns, CAP_SYS_ADMIN))
650 return ipcp;
651err:
652 return ERR_PTR(err);
653}
654
655#ifdef CONFIG_ARCH_WANT_IPC_PARSE_VERSION
656
657
658
659
660
661
662
663
664
665
666int ipc_parse_version(int *cmd)
667{
668 if (*cmd & IPC_64) {
669 *cmd ^= IPC_64;
670 return IPC_64;
671 } else {
672 return IPC_OLD;
673 }
674}
675
676#endif
677
678#ifdef CONFIG_PROC_FS
679struct ipc_proc_iter {
680 struct ipc_namespace *ns;
681 struct ipc_proc_iface *iface;
682};
683
684
685
686
687static struct kern_ipc_perm *sysvipc_find_ipc(struct ipc_ids *ids, loff_t pos,
688 loff_t *new_pos)
689{
690 struct kern_ipc_perm *ipc;
691 int total, id;
692
693 total = 0;
694 for (id = 0; id < pos && total < ids->in_use; id++) {
695 ipc = idr_find(&ids->ipcs_idr, id);
696 if (ipc != NULL)
697 total++;
698 }
699
700 if (total >= ids->in_use)
701 return NULL;
702
703 for (; pos < IPCMNI; pos++) {
704 ipc = idr_find(&ids->ipcs_idr, pos);
705 if (ipc != NULL) {
706 *new_pos = pos + 1;
707 rcu_read_lock();
708 ipc_lock_object(ipc);
709 return ipc;
710 }
711 }
712
713
714 return NULL;
715}
716
717static void *sysvipc_proc_next(struct seq_file *s, void *it, loff_t *pos)
718{
719 struct ipc_proc_iter *iter = s->private;
720 struct ipc_proc_iface *iface = iter->iface;
721 struct kern_ipc_perm *ipc = it;
722
723
724 if (ipc && ipc != SEQ_START_TOKEN)
725 ipc_unlock(ipc);
726
727 return sysvipc_find_ipc(&iter->ns->ids[iface->ids], *pos, pos);
728}
729
730
731
732
733
734static void *sysvipc_proc_start(struct seq_file *s, loff_t *pos)
735{
736 struct ipc_proc_iter *iter = s->private;
737 struct ipc_proc_iface *iface = iter->iface;
738 struct ipc_ids *ids;
739
740 ids = &iter->ns->ids[iface->ids];
741
742
743
744
745
746 down_read(&ids->rwsem);
747
748
749 if (*pos < 0)
750 return NULL;
751
752
753 if (*pos == 0)
754 return SEQ_START_TOKEN;
755
756
757 return sysvipc_find_ipc(ids, *pos - 1, pos);
758}
759
760static void sysvipc_proc_stop(struct seq_file *s, void *it)
761{
762 struct kern_ipc_perm *ipc = it;
763 struct ipc_proc_iter *iter = s->private;
764 struct ipc_proc_iface *iface = iter->iface;
765 struct ipc_ids *ids;
766
767
768 if (ipc && ipc != SEQ_START_TOKEN)
769 ipc_unlock(ipc);
770
771 ids = &iter->ns->ids[iface->ids];
772
773 up_read(&ids->rwsem);
774}
775
776static int sysvipc_proc_show(struct seq_file *s, void *it)
777{
778 struct ipc_proc_iter *iter = s->private;
779 struct ipc_proc_iface *iface = iter->iface;
780
781 if (it == SEQ_START_TOKEN) {
782 seq_puts(s, iface->header);
783 return 0;
784 }
785
786 return iface->show(s, it);
787}
788
789static const struct seq_operations sysvipc_proc_seqops = {
790 .start = sysvipc_proc_start,
791 .stop = sysvipc_proc_stop,
792 .next = sysvipc_proc_next,
793 .show = sysvipc_proc_show,
794};
795
796static int sysvipc_proc_open(struct inode *inode, struct file *file)
797{
798 struct ipc_proc_iter *iter;
799
800 iter = __seq_open_private(file, &sysvipc_proc_seqops, sizeof(*iter));
801 if (!iter)
802 return -ENOMEM;
803
804 iter->iface = PDE_DATA(inode);
805 iter->ns = get_ipc_ns(current->nsproxy->ipc_ns);
806
807 return 0;
808}
809
810static int sysvipc_proc_release(struct inode *inode, struct file *file)
811{
812 struct seq_file *seq = file->private_data;
813 struct ipc_proc_iter *iter = seq->private;
814 put_ipc_ns(iter->ns);
815 return seq_release_private(inode, file);
816}
817
818static const struct file_operations sysvipc_proc_fops = {
819 .open = sysvipc_proc_open,
820 .read = seq_read,
821 .llseek = seq_lseek,
822 .release = sysvipc_proc_release,
823};
824#endif
825