SAFE public projects git trees. - safe/jmp/linux-2.6/blob - ipc/util.c

   1 /*
   2  * linux/ipc/util.c
   3  * Copyright (C) 1992 Krishna Balasubramanian
   4  *
   5  * Sep 1997 - Call suser() last after "normal" permission checks so we
   6  *            get BSD style process accounting right.
   7  *            Occurs in several places in the IPC code.
   8  *            Chris Evans, <chris@ferret.lmh.ox.ac.uk>
   9  * Nov 1999 - ipc helper functions, unified SMP locking
  10  *            Manfred Spraul <manfred@colorfullife.com>
  11  * Oct 2002 - One lock per IPC id. RCU ipc_free for lock-free grow_ary().
  12  *            Mingming Cao <cmm@us.ibm.com>
  13  * Mar 2006 - support for audit of ipc object properties
  14  *            Dustin Kirkland <dustin.kirkland@us.ibm.com>
  15  * Jun 2006 - namespaces ssupport
  16  *            OpenVZ, SWsoft Inc.
  17  *            Pavel Emelianov <xemul@openvz.org>
  18  */
  19
  20 #include <linux/mm.h>
  21 #include <linux/shm.h>
  22 #include <linux/init.h>
  23 #include <linux/msg.h>
  24 #include <linux/vmalloc.h>
  25 #include <linux/slab.h>
  26 #include <linux/capability.h>
  27 #include <linux/highuid.h>
  28 #include <linux/security.h>
  29 #include <linux/rcupdate.h>
  30 #include <linux/workqueue.h>
  31 #include <linux/seq_file.h>
  32 #include <linux/proc_fs.h>
  33 #include <linux/audit.h>
  34 #include <linux/nsproxy.h>
  35 #include <linux/rwsem.h>
  36
  37 #include <asm/unistd.h>
  38
  39 #include "util.h"
  40
  41 struct ipc_proc_iface {
  42         const char *path;
  43         const char *header;
  44         int ids;
  45         int (*show)(struct seq_file *, void *);
  46 };
  47
  48 struct ipc_namespace init_ipc_ns = {
  49         .kref = {
  50                 .refcount       = ATOMIC_INIT(2),
  51         },
  52 };
  53
  54 static struct ipc_namespace *clone_ipc_ns(struct ipc_namespace *old_ns)
  55 {
  56         int err;
  57         struct ipc_namespace *ns;
  58
  59         err = -ENOMEM;
  60         ns = kmalloc(sizeof(struct ipc_namespace), GFP_KERNEL);
  61         if (ns == NULL)
  62                 goto err_mem;
  63
  64         err = sem_init_ns(ns);
  65         if (err)
  66                 goto err_sem;
  67         err = msg_init_ns(ns);
  68         if (err)
  69                 goto err_msg;
  70         err = shm_init_ns(ns);
  71         if (err)
  72                 goto err_shm;
  73
  74         kref_init(&ns->kref);
  75         return ns;
  76
  77 err_shm:
  78         msg_exit_ns(ns);
  79 err_msg:
  80         sem_exit_ns(ns);
  81 err_sem:
  82         kfree(ns);
  83 err_mem:
  84         return ERR_PTR(err);
  85 }
  86
  87 struct ipc_namespace *copy_ipcs(unsigned long flags, struct ipc_namespace *ns)
  88 {
  89         struct ipc_namespace *new_ns;
  90
  91         BUG_ON(!ns);
  92         get_ipc_ns(ns);
  93
  94         if (!(flags & CLONE_NEWIPC))
  95                 return ns;
  96
  97         new_ns = clone_ipc_ns(ns);
  98
  99         put_ipc_ns(ns);
 100         return new_ns;
 101 }
 102
 103 void free_ipc_ns(struct kref *kref)
 104 {
 105         struct ipc_namespace *ns;
 106
 107         ns = container_of(kref, struct ipc_namespace, kref);
 108         sem_exit_ns(ns);
 109         msg_exit_ns(ns);
 110         shm_exit_ns(ns);
 111         kfree(ns);
 112 }
 113
 114 /**
 115  *      ipc_init        -       initialise IPC subsystem
 116  *
 117  *      The various system5 IPC resources (semaphores, messages and shared
 118  *      memory) are initialised
 119  */
 120
 121 static int __init ipc_init(void)
 122 {
 123         sem_init();
 124         msg_init();
 125         shm_init();
 126         return 0;
 127 }
 128 __initcall(ipc_init);
 129
 130 /**
 131  *      ipc_init_ids            -       initialise IPC identifiers
 132  *      @ids: Identifier set
 133  *
 134  *      Set up the sequence range to use for the ipc identifier range (limited
 135  *      below IPCMNI) then initialise the ids idr.
 136  */
 137
 138 void ipc_init_ids(struct ipc_ids *ids)
 139 {
 140         init_rwsem(&ids->rw_mutex);
 141
 142         ids->in_use = 0;
 143         ids->seq = 0;
 144         {
 145                 int seq_limit = INT_MAX/SEQ_MULTIPLIER;
 146                 if(seq_limit > USHRT_MAX)
 147                         ids->seq_max = USHRT_MAX;
 148                  else
 149                         ids->seq_max = seq_limit;
 150         }
 151
 152         idr_init(&ids->ipcs_idr);
 153 }
 154
 155 #ifdef CONFIG_PROC_FS
 156 static const struct file_operations sysvipc_proc_fops;
 157 /**
 158  *      ipc_init_proc_interface -  Create a proc interface for sysipc types using a seq_file interface.
 159  *      @path: Path in procfs
 160  *      @header: Banner to be printed at the beginning of the file.
 161  *      @ids: ipc id table to iterate.
 162  *      @show: show routine.
 163  */
 164 void __init ipc_init_proc_interface(const char *path, const char *header,
 165                 int ids, int (*show)(struct seq_file *, void *))
 166 {
 167         struct proc_dir_entry *pde;
 168         struct ipc_proc_iface *iface;
 169
 170         iface = kmalloc(sizeof(*iface), GFP_KERNEL);
 171         if (!iface)
 172                 return;
 173         iface->path     = path;
 174         iface->header   = header;
 175         iface->ids      = ids;
 176         iface->show     = show;
 177
 178         pde = create_proc_entry(path,
 179                                 S_IRUGO,        /* world readable */
 180                                 NULL            /* parent dir */);
 181         if (pde) {
 182                 pde->data = iface;
 183                 pde->proc_fops = &sysvipc_proc_fops;
 184         } else {
 185                 kfree(iface);
 186         }
 187 }
 188 #endif
 189
 190 /**
 191  *      ipc_findkey     -       find a key in an ipc identifier set
 192  *      @ids: Identifier set
 193  *      @key: The key to find
 194  *
 195  *      Requires ipc_ids.rw_mutex locked.
 196  *      Returns the LOCKED pointer to the ipc structure if found or NULL
 197  *      if not.
 198  *      If key is found ipc points to the owning ipc structure
 199  */
 200
 201 static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key)
 202 {
 203         struct kern_ipc_perm *ipc;
 204         int next_id;
 205         int total;
 206
 207         for (total = 0, next_id = 0; total < ids->in_use; next_id++) {
 208                 ipc = idr_find(&ids->ipcs_idr, next_id);
 209
 210                 if (ipc == NULL)
 211                         continue;
 212
 213                 if (ipc->key != key) {
 214                         total++;
 215                         continue;
 216                 }
 217
 218                 ipc_lock_by_ptr(ipc);
 219                 return ipc;
 220         }
 221
 222         return NULL;
 223 }
 224
 225 /**
 226  *      ipc_get_maxid   -       get the last assigned id
 227  *      @ids: IPC identifier set
 228  *
 229  *      Called with ipc_ids.rw_mutex held.
 230  */
 231
 232 int ipc_get_maxid(struct ipc_ids *ids)
 233 {
 234         struct kern_ipc_perm *ipc;
 235         int max_id = -1;
 236         int total, id;
 237
 238         if (ids->in_use == 0)
 239                 return -1;
 240
 241         if (ids->in_use == IPCMNI)
 242                 return IPCMNI - 1;
 243
 244         /* Look for the last assigned id */
 245         total = 0;
 246         for (id = 0; id < IPCMNI && total < ids->in_use; id++) {
 247                 ipc = idr_find(&ids->ipcs_idr, id);
 248                 if (ipc != NULL) {
 249                         max_id = id;
 250                         total++;
 251                 }
 252         }
 253         return max_id;
 254 }
 255
 256 /**
 257  *      ipc_addid       -       add an IPC identifier
 258  *      @ids: IPC identifier set
 259  *      @new: new IPC permission set
 260  *      @size: limit for the number of used ids
 261  *
 262  *      Add an entry 'new' to the IPC ids idr. The permissions object is
 263  *      initialised and the first free entry is set up and the id assigned
 264  *      is returned. The 'new' entry is returned in a locked state on success.
 265  *      On failure the entry is not locked and -1 is returned.
 266  *
 267  *      Called with ipc_ids.rw_mutex held as a writer.
 268  */
 269
 270 int ipc_addid(struct ipc_ids* ids, struct kern_ipc_perm* new, int size)
 271 {
 272         int id, err;
 273
 274         if (size > IPCMNI)
 275                 size = IPCMNI;
 276
 277         if (ids->in_use >= size)
 278                 return -1;
 279
 280         err = idr_get_new(&ids->ipcs_idr, new, &id);
 281         if (err)
 282                 return -1;
 283
 284         ids->in_use++;
 285
 286         new->cuid = new->uid = current->euid;
 287         new->gid = new->cgid = current->egid;
 288
 289         new->seq = ids->seq++;
 290         if(ids->seq > ids->seq_max)
 291                 ids->seq = 0;
 292
 293         spin_lock_init(&new->lock);
 294         new->deleted = 0;
 295         rcu_read_lock();
 296         spin_lock(&new->lock);
 297         return id;
 298 }
 299
 300 /**
 301  *      ipcget_new      -       create a new ipc object
 302  *      @ns: namespace
 303  *      @ids: IPC identifer set
 304  *      @ops: the actual creation routine to call
 305  *      @params: its parameters
 306  *
 307  *      This routine is called by sys_msgget, sys_semget() and sys_shmget()
 308  *      when the key is IPC_PRIVATE.
 309  */
 310 int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids,
 311                 struct ipc_ops *ops, struct ipc_params *params)
 312 {
 313         int err;
 314
 315         err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL);
 316
 317         if (!err)
 318                 return -ENOMEM;
 319
 320         down_write(&ids->rw_mutex);
 321         err = ops->getnew(ns, params);
 322         up_write(&ids->rw_mutex);
 323
 324         return err;
 325 }
 326
 327 /**
 328  *      ipc_check_perms -       check security and permissions for an IPC
 329  *      @ipcp: ipc permission set
 330  *      @ops: the actual security routine to call
 331  *      @params: its parameters
 332  *
 333  *      This routine is called by sys_msgget(), sys_semget() and sys_shmget()
 334  *      when the key is not IPC_PRIVATE and that key already exists in the
 335  *      ids IDR.
 336  *
 337  *      On success, the IPC id is returned.
 338  *
 339  *      It is called with ipc_ids.rw_mutex and ipcp->lock held.
 340  */
 341 static int ipc_check_perms(struct kern_ipc_perm *ipcp, struct ipc_ops *ops,
 342                         struct ipc_params *params)
 343 {
 344         int err;
 345
 346         if (ipcperms(ipcp, params->flg))
 347                 err = -EACCES;
 348         else {
 349                 err = ops->associate(ipcp, params->flg);
 350                 if (!err)
 351                         err = ipcp->id;
 352         }
 353
 354         return err;
 355 }
 356
 357 /**
 358  *      ipcget_public   -       get an ipc object or create a new one
 359  *      @ns: namespace
 360  *      @ids: IPC identifer set
 361  *      @ops: the actual creation routine to call
 362  *      @params: its parameters
 363  *
 364  *      This routine is called by sys_msgget, sys_semget() and sys_shmget()
 365  *      when the key is not IPC_PRIVATE.
 366  *      It adds a new entry if the key is not found and does some permission
 367  *      / security checkings if the key is found.
 368  *
 369  *      On success, the ipc id is returned.
 370  */
 371 int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
 372                 struct ipc_ops *ops, struct ipc_params *params)
 373 {
 374         struct kern_ipc_perm *ipcp;
 375         int flg = params->flg;
 376         int err;
 377
 378         err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL);
 379
 380         /*
 381          * Take the lock as a writer since we are potentially going to add
 382          * a new entry + read locks are not "upgradable"
 383          */
 384         down_write(&ids->rw_mutex);
 385         ipcp = ipc_findkey(ids, params->key);
 386         if (ipcp == NULL) {
 387                 /* key not used */
 388                 if (!(flg & IPC_CREAT))
 389                         err = -ENOENT;
 390                 else if (!err)
 391                         err = -ENOMEM;
 392                 else
 393                         err = ops->getnew(ns, params);
 394         } else {
 395                 /* ipc object has been locked by ipc_findkey() */
 396
 397                 if (flg & IPC_CREAT && flg & IPC_EXCL)
 398                         err = -EEXIST;
 399                 else {
 400                         err = 0;
 401                         if (ops->more_checks)
 402                                 err = ops->more_checks(ipcp, params);
 403                         if (!err)
 404                                 /*
 405                                  * ipc_check_perms returns the IPC id on
 406                                  * success
 407                                  */
 408                                 err = ipc_check_perms(ipcp, ops, params);
 409                 }
 410                 ipc_unlock(ipcp);
 411         }
 412         up_write(&ids->rw_mutex);
 413
 414         return err;
 415 }
 416
 417
 418 /**
 419  *      ipc_rmid        -       remove an IPC identifier
 420  *      @ids: IPC identifier set
 421  *      @ipcp: ipc perm structure containing the identifier to remove
 422  *
 423  *      ipc_ids.rw_mutex (as a writer) and the spinlock for this ID are held
 424  *      before this function is called, and remain locked on the exit.
 425  */
 426
 427 void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
 428 {
 429         int lid = ipcid_to_idx(ipcp->id);
 430
 431         idr_remove(&ids->ipcs_idr, lid);
 432
 433         ids->in_use--;
 434
 435         ipcp->deleted = 1;
 436
 437         return;
 438 }
 439
 440 /**
 441  *      ipc_alloc       -       allocate ipc space
 442  *      @size: size desired
 443  *
 444  *      Allocate memory from the appropriate pools and return a pointer to it.
 445  *      NULL is returned if the allocation fails
 446  */
 447
 448 void* ipc_alloc(int size)
 449 {
 450         void* out;
 451         if(size > PAGE_SIZE)
 452                 out = vmalloc(size);
 453         else
 454                 out = kmalloc(size, GFP_KERNEL);
 455         return out;
 456 }
 457
 458 /**
 459  *      ipc_free        -       free ipc space
 460  *      @ptr: pointer returned by ipc_alloc
 461  *      @size: size of block
 462  *
 463  *      Free a block created with ipc_alloc(). The caller must know the size
 464  *      used in the allocation call.
 465  */
 466
 467 void ipc_free(void* ptr, int size)
 468 {
 469         if(size > PAGE_SIZE)
 470                 vfree(ptr);
 471         else
 472                 kfree(ptr);
 473 }
 474
 475 /*
 476  * rcu allocations:
 477  * There are three headers that are prepended to the actual allocation:
 478  * - during use: ipc_rcu_hdr.
 479  * - during the rcu grace period: ipc_rcu_grace.
 480  * - [only if vmalloc]: ipc_rcu_sched.
 481  * Their lifetime doesn't overlap, thus the headers share the same memory.
 482  * Unlike a normal union, they are right-aligned, thus some container_of
 483  * forward/backward casting is necessary:
 484  */
 485 struct ipc_rcu_hdr
 486 {
 487         int refcount;
 488         int is_vmalloc;
 489         void *data[0];
 490 };
 491
 492
 493 struct ipc_rcu_grace
 494 {
 495         struct rcu_head rcu;
 496         /* "void *" makes sure alignment of following data is sane. */
 497         void *data[0];
 498 };
 499
 500 struct ipc_rcu_sched
 501 {
 502         struct work_struct work;
 503         /* "void *" makes sure alignment of following data is sane. */
 504         void *data[0];
 505 };
 506
 507 #define HDRLEN_KMALLOC          (sizeof(struct ipc_rcu_grace) > sizeof(struct ipc_rcu_hdr) ? \
 508                                         sizeof(struct ipc_rcu_grace) : sizeof(struct ipc_rcu_hdr))
 509 #define HDRLEN_VMALLOC          (sizeof(struct ipc_rcu_sched) > HDRLEN_KMALLOC ? \
 510                                         sizeof(struct ipc_rcu_sched) : HDRLEN_KMALLOC)
 511
 512 static inline int rcu_use_vmalloc(int size)
 513 {
 514         /* Too big for a single page? */
 515         if (HDRLEN_KMALLOC + size > PAGE_SIZE)
 516                 return 1;
 517         return 0;
 518 }
 519
 520 /**
 521  *      ipc_rcu_alloc   -       allocate ipc and rcu space
 522  *      @size: size desired
 523  *
 524  *      Allocate memory for the rcu header structure +  the object.
 525  *      Returns the pointer to the object.
 526  *      NULL is returned if the allocation fails.
 527  */
 528
 529 void* ipc_rcu_alloc(int size)
 530 {
 531         void* out;
 532         /*
 533          * We prepend the allocation with the rcu struct, and
 534          * workqueue if necessary (for vmalloc).
 535          */
 536         if (rcu_use_vmalloc(size)) {
 537                 out = vmalloc(HDRLEN_VMALLOC + size);
 538                 if (out) {
 539                         out += HDRLEN_VMALLOC;
 540                         container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 1;
 541                         container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
 542                 }
 543         } else {
 544                 out = kmalloc(HDRLEN_KMALLOC + size, GFP_KERNEL);
 545                 if (out) {
 546                         out += HDRLEN_KMALLOC;
 547                         container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 0;
 548                         container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
 549                 }
 550         }
 551
 552         return out;
 553 }
 554
 555 void ipc_rcu_getref(void *ptr)
 556 {
 557         container_of(ptr, struct ipc_rcu_hdr, data)->refcount++;
 558 }
 559
 560 static void ipc_do_vfree(struct work_struct *work)
 561 {
 562         vfree(container_of(work, struct ipc_rcu_sched, work));
 563 }
 564
 565 /**
 566  * ipc_schedule_free - free ipc + rcu space
 567  * @head: RCU callback structure for queued work
 568  *
 569  * Since RCU callback function is called in bh,
 570  * we need to defer the vfree to schedule_work().
 571  */
 572 static void ipc_schedule_free(struct rcu_head *head)
 573 {
 574         struct ipc_rcu_grace *grace;
 575         struct ipc_rcu_sched *sched;
 576
 577         grace = container_of(head, struct ipc_rcu_grace, rcu);
 578         sched = container_of(&(grace->data[0]), struct ipc_rcu_sched,
 579                                 data[0]);
 580
 581         INIT_WORK(&sched->work, ipc_do_vfree);
 582         schedule_work(&sched->work);
 583 }
 584
 585 /**
 586  * ipc_immediate_free - free ipc + rcu space
 587  * @head: RCU callback structure that contains pointer to be freed
 588  *
 589  * Free from the RCU callback context.
 590  */
 591 static void ipc_immediate_free(struct rcu_head *head)
 592 {
 593         struct ipc_rcu_grace *free =
 594                 container_of(head, struct ipc_rcu_grace, rcu);
 595         kfree(free);
 596 }
 597
 598 void ipc_rcu_putref(void *ptr)
 599 {
 600         if (--container_of(ptr, struct ipc_rcu_hdr, data)->refcount > 0)
 601                 return;
 602
 603         if (container_of(ptr, struct ipc_rcu_hdr, data)->is_vmalloc) {
 604                 call_rcu(&container_of(ptr, struct ipc_rcu_grace, data)->rcu,
 605                                 ipc_schedule_free);
 606         } else {
 607                 call_rcu(&container_of(ptr, struct ipc_rcu_grace, data)->rcu,
 608                                 ipc_immediate_free);
 609         }
 610 }
 611
 612 /**
 613  *      ipcperms        -       check IPC permissions
 614  *      @ipcp: IPC permission set
 615  *      @flag: desired permission set.
 616  *
 617  *      Check user, group, other permissions for access
 618  *      to ipc resources. return 0 if allowed
 619  */
 620
 621 int ipcperms (struct kern_ipc_perm *ipcp, short flag)
 622 {       /* flag will most probably be 0 or S_...UGO from <linux/stat.h> */
 623         int requested_mode, granted_mode, err;
 624
 625         if (unlikely((err = audit_ipc_obj(ipcp))))
 626                 return err;
 627         requested_mode = (flag >> 6) | (flag >> 3) | flag;
 628         granted_mode = ipcp->mode;
 629         if (current->euid == ipcp->cuid || current->euid == ipcp->uid)
 630                 granted_mode >>= 6;
 631         else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
 632                 granted_mode >>= 3;
 633         /* is there some bit set in requested_mode but not in granted_mode? */
 634         if ((requested_mode & ~granted_mode & 0007) &&
 635             !capable(CAP_IPC_OWNER))
 636                 return -1;
 637
 638         return security_ipc_permission(ipcp, flag);
 639 }
 640
 641 /*
 642  * Functions to convert between the kern_ipc_perm structure and the
 643  * old/new ipc_perm structures
 644  */
 645
 646 /**
 647  *      kernel_to_ipc64_perm    -       convert kernel ipc permissions to user
 648  *      @in: kernel permissions
 649  *      @out: new style IPC permissions
 650  *
 651  *      Turn the kernel object @in into a set of permissions descriptions
 652  *      for returning to userspace (@out).
 653  */
 654
 655
 656 void kernel_to_ipc64_perm (struct kern_ipc_perm *in, struct ipc64_perm *out)
 657 {
 658         out->key        = in->key;
 659         out->uid        = in->uid;
 660         out->gid        = in->gid;
 661         out->cuid       = in->cuid;
 662         out->cgid       = in->cgid;
 663         out->mode       = in->mode;
 664         out->seq        = in->seq;
 665 }
 666
 667 /**
 668  *      ipc64_perm_to_ipc_perm  -       convert new ipc permissions to old
 669  *      @in: new style IPC permissions
 670  *      @out: old style IPC permissions
 671  *
 672  *      Turn the new style permissions object @in into a compatibility
 673  *      object and store it into the @out pointer.
 674  */
 675
 676 void ipc64_perm_to_ipc_perm (struct ipc64_perm *in, struct ipc_perm *out)
 677 {
 678         out->key        = in->key;
 679         SET_UID(out->uid, in->uid);
 680         SET_GID(out->gid, in->gid);
 681         SET_UID(out->cuid, in->cuid);
 682         SET_GID(out->cgid, in->cgid);
 683         out->mode       = in->mode;
 684         out->seq        = in->seq;
 685 }
 686
 687 /**
 688  * ipc_lock - Lock an ipc structure without rw_mutex held
 689  * @ids: IPC identifier set
 690  * @id: ipc id to look for
 691  *
 692  * Look for an id in the ipc ids idr and lock the associated ipc object.
 693  *
 694  * The ipc object is locked on exit.
 695  *
 696  * This is the routine that should be called when the rw_mutex is not already
 697  * held, i.e. idr tree not protected: it protects the idr tree in read mode
 698  * during the idr_find().
 699  */
 700
 701 struct kern_ipc_perm *ipc_lock(struct ipc_ids *ids, int id)
 702 {
 703         struct kern_ipc_perm *out;
 704         int lid = ipcid_to_idx(id);
 705
 706         down_read(&ids->rw_mutex);
 707
 708         rcu_read_lock();
 709         out = idr_find(&ids->ipcs_idr, lid);
 710         if (out == NULL) {
 711                 rcu_read_unlock();
 712                 up_read(&ids->rw_mutex);
 713                 return ERR_PTR(-EINVAL);
 714         }
 715
 716         up_read(&ids->rw_mutex);
 717
 718         spin_lock(&out->lock);
 719
 720         /* ipc_rmid() may have already freed the ID while ipc_lock
 721          * was spinning: here verify that the structure is still valid
 722          */
 723         if (out->deleted) {
 724                 spin_unlock(&out->lock);
 725                 rcu_read_unlock();
 726                 return ERR_PTR(-EINVAL);
 727         }
 728
 729         return out;
 730 }
 731
 732 /**
 733  * ipc_lock_down - Lock an ipc structure with rw_sem held
 734  * @ids: IPC identifier set
 735  * @id: ipc id to look for
 736  *
 737  * Look for an id in the ipc ids idr and lock the associated ipc object.
 738  *
 739  * The ipc object is locked on exit.
 740  *
 741  * This is the routine that should be called when the rw_mutex is already
 742  * held, i.e. idr tree protected.
 743  */
 744
 745 struct kern_ipc_perm *ipc_lock_down(struct ipc_ids *ids, int id)
 746 {
 747         struct kern_ipc_perm *out;
 748         int lid = ipcid_to_idx(id);
 749
 750         rcu_read_lock();
 751         out = idr_find(&ids->ipcs_idr, lid);
 752         if (out == NULL) {
 753                 rcu_read_unlock();
 754                 return ERR_PTR(-EINVAL);
 755         }
 756
 757         spin_lock(&out->lock);
 758
 759         /*
 760          * No need to verify that the structure is still valid since the
 761          * rw_mutex is held.
 762          */
 763         return out;
 764 }
 765
 766 #ifdef __ARCH_WANT_IPC_PARSE_VERSION
 767
 768
 769 /**
 770  *      ipc_parse_version       -       IPC call version
 771  *      @cmd: pointer to command
 772  *
 773  *      Return IPC_64 for new style IPC and IPC_OLD for old style IPC.
 774  *      The @cmd value is turned from an encoding command and version into
 775  *      just the command code.
 776  */
 777
 778 int ipc_parse_version (int *cmd)
 779 {
 780         if (*cmd & IPC_64) {
 781                 *cmd ^= IPC_64;
 782                 return IPC_64;
 783         } else {
 784                 return IPC_OLD;
 785         }
 786 }
 787
 788 #endif /* __ARCH_WANT_IPC_PARSE_VERSION */
 789
 790 #ifdef CONFIG_PROC_FS
 791 struct ipc_proc_iter {
 792         struct ipc_namespace *ns;
 793         struct ipc_proc_iface *iface;
 794 };
 795
 796 /*
 797  * This routine locks the ipc structure found at least at position pos.
 798  */
 799 struct kern_ipc_perm *sysvipc_find_ipc(struct ipc_ids *ids, loff_t pos,
 800                                         loff_t *new_pos)
 801 {
 802         struct kern_ipc_perm *ipc;
 803         int total, id;
 804
 805         total = 0;
 806         for (id = 0; id < pos && total < ids->in_use; id++) {
 807                 ipc = idr_find(&ids->ipcs_idr, id);
 808                 if (ipc != NULL)
 809                         total++;
 810         }
 811
 812         if (total >= ids->in_use)
 813                 return NULL;
 814
 815         for ( ; pos < IPCMNI; pos++) {
 816                 ipc = idr_find(&ids->ipcs_idr, pos);
 817                 if (ipc != NULL) {
 818                         *new_pos = pos + 1;
 819                         ipc_lock_by_ptr(ipc);
 820                         return ipc;
 821                 }
 822         }
 823
 824         /* Out of range - return NULL to terminate iteration */
 825         return NULL;
 826 }
 827
 828 static void *sysvipc_proc_next(struct seq_file *s, void *it, loff_t *pos)
 829 {
 830         struct ipc_proc_iter *iter = s->private;
 831         struct ipc_proc_iface *iface = iter->iface;
 832         struct kern_ipc_perm *ipc = it;
 833
 834         /* If we had an ipc id locked before, unlock it */
 835         if (ipc && ipc != SEQ_START_TOKEN)
 836                 ipc_unlock(ipc);
 837
 838         return sysvipc_find_ipc(iter->ns->ids[iface->ids], *pos, pos);
 839 }
 840
 841 /*
 842  * File positions: pos 0 -> header, pos n -> ipc id = n - 1.
 843  * SeqFile iterator: iterator value locked ipc pointer or SEQ_TOKEN_START.
 844  */
 845 static void *sysvipc_proc_start(struct seq_file *s, loff_t *pos)
 846 {
 847         struct ipc_proc_iter *iter = s->private;
 848         struct ipc_proc_iface *iface = iter->iface;
 849         struct ipc_ids *ids;
 850
 851         ids = iter->ns->ids[iface->ids];
 852
 853         /*
 854          * Take the lock - this will be released by the corresponding
 855          * call to stop().
 856          */
 857         down_read(&ids->rw_mutex);
 858
 859         /* pos < 0 is invalid */
 860         if (*pos < 0)
 861                 return NULL;
 862
 863         /* pos == 0 means header */
 864         if (*pos == 0)
 865                 return SEQ_START_TOKEN;
 866
 867         /* Find the (pos-1)th ipc */
 868         return sysvipc_find_ipc(ids, *pos - 1, pos);
 869 }
 870
 871 static void sysvipc_proc_stop(struct seq_file *s, void *it)
 872 {
 873         struct kern_ipc_perm *ipc = it;
 874         struct ipc_proc_iter *iter = s->private;
 875         struct ipc_proc_iface *iface = iter->iface;
 876         struct ipc_ids *ids;
 877
 878         /* If we had a locked structure, release it */
 879         if (ipc && ipc != SEQ_START_TOKEN)
 880                 ipc_unlock(ipc);
 881
 882         ids = iter->ns->ids[iface->ids];
 883         /* Release the lock we took in start() */
 884         up_read(&ids->rw_mutex);
 885 }
 886
 887 static int sysvipc_proc_show(struct seq_file *s, void *it)
 888 {
 889         struct ipc_proc_iter *iter = s->private;
 890         struct ipc_proc_iface *iface = iter->iface;
 891
 892         if (it == SEQ_START_TOKEN)
 893                 return seq_puts(s, iface->header);
 894
 895         return iface->show(s, it);
 896 }
 897
 898 static struct seq_operations sysvipc_proc_seqops = {
 899         .start = sysvipc_proc_start,
 900         .stop  = sysvipc_proc_stop,
 901         .next  = sysvipc_proc_next,
 902         .show  = sysvipc_proc_show,
 903 };
 904
 905 static int sysvipc_proc_open(struct inode *inode, struct file *file)
 906 {
 907         int ret;
 908         struct seq_file *seq;
 909         struct ipc_proc_iter *iter;
 910
 911         ret = -ENOMEM;
 912         iter = kmalloc(sizeof(*iter), GFP_KERNEL);
 913         if (!iter)
 914                 goto out;
 915
 916         ret = seq_open(file, &sysvipc_proc_seqops);
 917         if (ret)
 918                 goto out_kfree;
 919
 920         seq = file->private_data;
 921         seq->private = iter;
 922
 923         iter->iface = PDE(inode)->data;
 924         iter->ns    = get_ipc_ns(current->nsproxy->ipc_ns);
 925 out:
 926         return ret;
 927 out_kfree:
 928         kfree(iter);
 929         goto out;
 930 }
 931
 932 static int sysvipc_proc_release(struct inode *inode, struct file *file)
 933 {
 934         struct seq_file *seq = file->private_data;
 935         struct ipc_proc_iter *iter = seq->private;
 936         put_ipc_ns(iter->ns);
 937         return seq_release_private(inode, file);
 938 }
 939
 940 static const struct file_operations sysvipc_proc_fops = {
 941         .open    = sysvipc_proc_open,
 942         .read    = seq_read,
 943         .llseek  = seq_lseek,
 944         .release = sysvipc_proc_release,
 945 };
 946 #endif /* CONFIG_PROC_FS */