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 * General sysv ipc locking scheme: 20 * rcu_read_lock() 21 * obtain the ipc object (kern_ipc_perm) by looking up the id in an idr 22 * tree. 23 * - perform initial checks (capabilities, auditing and permission, 24 * etc). 25 * - perform read-only operations, such as STAT, INFO commands. 26 * acquire the ipc lock (kern_ipc_perm.lock) through 27 * ipc_lock_object() 28 * - perform data updates, such as SET, RMID commands and 29 * mechanism-specific operations (semop/semtimedop, 30 * msgsnd/msgrcv, shmat/shmdt). 31 * drop the ipc lock, through ipc_unlock_object(). 32 * rcu_read_unlock() 33 * 34 * The ids->rwsem must be taken when: 35 * - creating, removing and iterating the existing entries in ipc 36 * identifier sets. 37 * - iterating through files under /proc/sysvipc/ 38 * 39 * Note that sems have a special fast path that avoids kern_ipc_perm.lock - 40 * see sem_lock(). 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 67 struct 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 * ipc_init - initialise ipc subsystem 76 * 77 * The various sysv ipc resources (semaphores, messages and shared 78 * memory) are initialised. 79 * 80 * A callback routine is registered into the memory hotplug notifier 81 * chain: since msgmni scales to lowmem this callback routine will be 82 * called upon successful memory add / remove to recompute msmgni. 83 */ 84 static int __init ipc_init(void) 85 { 86 sem_init(); 87 msg_init(); 88 shm_init(); 89 return 0; 90 } 91 device_initcall(ipc_init); 92 93 /** 94 * ipc_init_ids - initialise ipc identifiers 95 * @ids: ipc identifier set 96 * 97 * Set up the sequence range to use for the ipc identifier range (limited 98 * below IPCMNI) then initialise the ids idr. 99 */ 100 void 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 110 static const struct file_operations sysvipc_proc_fops; 111 /** 112 * ipc_init_proc_interface - create a proc interface for sysipc types using a seq_file interface. 113 * @path: Path in procfs 114 * @header: Banner to be printed at the beginning of the file. 115 * @ids: ipc id table to iterate. 116 * @show: show routine. 117 */ 118 void __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, /* world readable */ 134 NULL, /* parent dir */ 135 &sysvipc_proc_fops, 136 iface); 137 if (!pde) 138 kfree(iface); 139 } 140 #endif 141 142 /** 143 * ipc_findkey - find a key in an ipc identifier set 144 * @ids: ipc identifier set 145 * @key: key to find 146 * 147 * Returns the locked pointer to the ipc structure if found or NULL 148 * otherwise. If key is found ipc points to the owning ipc structure 149 * 150 * Called with ipc_ids.rwsem held. 151 */ 152 static 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 * ipc_get_maxid - get the last assigned id 179 * @ids: ipc identifier set 180 * 181 * Called with ipc_ids.rwsem held. 182 */ 183 int 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 /* Look for the last assigned id */ 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 * ipc_addid - add an ipc identifier 209 * @ids: ipc identifier set 210 * @new: new ipc permission set 211 * @size: limit for the number of used ids 212 * 213 * Add an entry 'new' to the ipc ids idr. The permissions object is 214 * initialised and the first free entry is set up and the id assigned 215 * is returned. The 'new' entry is returned in a locked state on success. 216 * On failure the entry is not locked and a negative err-code is returned. 217 * 218 * Called with writer ipc_ids.rwsem held. 219 */ 220 int 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 spin_lock_init(&new->lock); 236 new->deleted = false; 237 rcu_read_lock(); 238 spin_lock(&new->lock); 239 240 current_euid_egid(&euid, &egid); 241 new->cuid = new->uid = euid; 242 new->gid = new->cgid = egid; 243 244 id = idr_alloc(&ids->ipcs_idr, new, 245 (next_id < 0) ? 0 : ipcid_to_idx(next_id), 0, 246 GFP_NOWAIT); 247 idr_preload_end(); 248 if (id < 0) { 249 spin_unlock(&new->lock); 250 rcu_read_unlock(); 251 return id; 252 } 253 254 ids->in_use++; 255 256 if (next_id < 0) { 257 new->seq = ids->seq++; 258 if (ids->seq > IPCID_SEQ_MAX) 259 ids->seq = 0; 260 } else { 261 new->seq = ipcid_to_seqx(next_id); 262 ids->next_id = -1; 263 } 264 265 new->id = ipc_buildid(id, new->seq); 266 return id; 267 } 268 269 /** 270 * ipcget_new - create a new ipc object 271 * @ns: ipc namespace 272 * @ids: ipc identifier set 273 * @ops: the actual creation routine to call 274 * @params: its parameters 275 * 276 * This routine is called by sys_msgget, sys_semget() and sys_shmget() 277 * when the key is IPC_PRIVATE. 278 */ 279 static int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids, 280 const struct ipc_ops *ops, struct ipc_params *params) 281 { 282 int err; 283 284 down_write(&ids->rwsem); 285 err = ops->getnew(ns, params); 286 up_write(&ids->rwsem); 287 return err; 288 } 289 290 /** 291 * ipc_check_perms - check security and permissions for an ipc object 292 * @ns: ipc namespace 293 * @ipcp: ipc permission set 294 * @ops: the actual security routine to call 295 * @params: its parameters 296 * 297 * This routine is called by sys_msgget(), sys_semget() and sys_shmget() 298 * when the key is not IPC_PRIVATE and that key already exists in the 299 * ds IDR. 300 * 301 * On success, the ipc id is returned. 302 * 303 * It is called with ipc_ids.rwsem and ipcp->lock held. 304 */ 305 static int ipc_check_perms(struct ipc_namespace *ns, 306 struct kern_ipc_perm *ipcp, 307 const struct ipc_ops *ops, 308 struct ipc_params *params) 309 { 310 int err; 311 312 if (ipcperms(ns, ipcp, params->flg)) 313 err = -EACCES; 314 else { 315 err = ops->associate(ipcp, params->flg); 316 if (!err) 317 err = ipcp->id; 318 } 319 320 return err; 321 } 322 323 /** 324 * ipcget_public - get an ipc object or create a new one 325 * @ns: ipc namespace 326 * @ids: ipc identifier set 327 * @ops: the actual creation routine to call 328 * @params: its parameters 329 * 330 * This routine is called by sys_msgget, sys_semget() and sys_shmget() 331 * when the key is not IPC_PRIVATE. 332 * It adds a new entry if the key is not found and does some permission 333 * / security checkings if the key is found. 334 * 335 * On success, the ipc id is returned. 336 */ 337 static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids, 338 const struct ipc_ops *ops, struct ipc_params *params) 339 { 340 struct kern_ipc_perm *ipcp; 341 int flg = params->flg; 342 int err; 343 344 /* 345 * Take the lock as a writer since we are potentially going to add 346 * a new entry + read locks are not "upgradable" 347 */ 348 down_write(&ids->rwsem); 349 ipcp = ipc_findkey(ids, params->key); 350 if (ipcp == NULL) { 351 /* key not used */ 352 if (!(flg & IPC_CREAT)) 353 err = -ENOENT; 354 else 355 err = ops->getnew(ns, params); 356 } else { 357 /* ipc object has been locked by ipc_findkey() */ 358 359 if (flg & IPC_CREAT && flg & IPC_EXCL) 360 err = -EEXIST; 361 else { 362 err = 0; 363 if (ops->more_checks) 364 err = ops->more_checks(ipcp, params); 365 if (!err) 366 /* 367 * ipc_check_perms returns the IPC id on 368 * success 369 */ 370 err = ipc_check_perms(ns, ipcp, ops, params); 371 } 372 ipc_unlock(ipcp); 373 } 374 up_write(&ids->rwsem); 375 376 return err; 377 } 378 379 380 /** 381 * ipc_rmid - remove an ipc identifier 382 * @ids: ipc identifier set 383 * @ipcp: ipc perm structure containing the identifier to remove 384 * 385 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held 386 * before this function is called, and remain locked on the exit. 387 */ 388 void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp) 389 { 390 int lid = ipcid_to_idx(ipcp->id); 391 392 idr_remove(&ids->ipcs_idr, lid); 393 ids->in_use--; 394 ipcp->deleted = true; 395 } 396 397 /** 398 * ipc_alloc - allocate ipc space 399 * @size: size desired 400 * 401 * Allocate memory from the appropriate pools and return a pointer to it. 402 * NULL is returned if the allocation fails 403 */ 404 void *ipc_alloc(int size) 405 { 406 return kvmalloc(size, GFP_KERNEL); 407 } 408 409 /** 410 * ipc_free - free ipc space 411 * @ptr: pointer returned by ipc_alloc 412 * 413 * Free a block created with ipc_alloc(). 414 */ 415 void ipc_free(void *ptr) 416 { 417 kvfree(ptr); 418 } 419 420 /** 421 * ipc_rcu_alloc - allocate ipc and rcu space 422 * @size: size desired 423 * 424 * Allocate memory for the rcu header structure + the object. 425 * Returns the pointer to the object or NULL upon failure. 426 */ 427 void *ipc_rcu_alloc(int size) 428 { 429 /* 430 * We prepend the allocation with the rcu struct 431 */ 432 struct ipc_rcu *out = ipc_alloc(sizeof(struct ipc_rcu) + size); 433 if (unlikely(!out)) 434 return NULL; 435 atomic_set(&out->refcount, 1); 436 return out + 1; 437 } 438 439 int ipc_rcu_getref(void *ptr) 440 { 441 struct ipc_rcu *p = ((struct ipc_rcu *)ptr) - 1; 442 443 return atomic_inc_not_zero(&p->refcount); 444 } 445 446 void ipc_rcu_putref(void *ptr, void (*func)(struct rcu_head *head)) 447 { 448 struct ipc_rcu *p = ((struct ipc_rcu *)ptr) - 1; 449 450 if (!atomic_dec_and_test(&p->refcount)) 451 return; 452 453 call_rcu(&p->rcu, func); 454 } 455 456 void ipc_rcu_free(struct rcu_head *head) 457 { 458 struct ipc_rcu *p = container_of(head, struct ipc_rcu, rcu); 459 460 kvfree(p); 461 } 462 463 /** 464 * ipcperms - check ipc permissions 465 * @ns: ipc namespace 466 * @ipcp: ipc permission set 467 * @flag: desired permission set 468 * 469 * Check user, group, other permissions for access 470 * to ipc resources. return 0 if allowed 471 * 472 * @flag will most probably be 0 or ``S_...UGO`` from <linux/stat.h> 473 */ 474 int ipcperms(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp, short flag) 475 { 476 kuid_t euid = current_euid(); 477 int requested_mode, granted_mode; 478 479 audit_ipc_obj(ipcp); 480 requested_mode = (flag >> 6) | (flag >> 3) | flag; 481 granted_mode = ipcp->mode; 482 if (uid_eq(euid, ipcp->cuid) || 483 uid_eq(euid, ipcp->uid)) 484 granted_mode >>= 6; 485 else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid)) 486 granted_mode >>= 3; 487 /* is there some bit set in requested_mode but not in granted_mode? */ 488 if ((requested_mode & ~granted_mode & 0007) && 489 !ns_capable(ns->user_ns, CAP_IPC_OWNER)) 490 return -1; 491 492 return security_ipc_permission(ipcp, flag); 493 } 494 495 /* 496 * Functions to convert between the kern_ipc_perm structure and the 497 * old/new ipc_perm structures 498 */ 499 500 /** 501 * kernel_to_ipc64_perm - convert kernel ipc permissions to user 502 * @in: kernel permissions 503 * @out: new style ipc permissions 504 * 505 * Turn the kernel object @in into a set of permissions descriptions 506 * for returning to userspace (@out). 507 */ 508 void kernel_to_ipc64_perm(struct kern_ipc_perm *in, struct ipc64_perm *out) 509 { 510 out->key = in->key; 511 out->uid = from_kuid_munged(current_user_ns(), in->uid); 512 out->gid = from_kgid_munged(current_user_ns(), in->gid); 513 out->cuid = from_kuid_munged(current_user_ns(), in->cuid); 514 out->cgid = from_kgid_munged(current_user_ns(), in->cgid); 515 out->mode = in->mode; 516 out->seq = in->seq; 517 } 518 519 /** 520 * ipc64_perm_to_ipc_perm - convert new ipc permissions to old 521 * @in: new style ipc permissions 522 * @out: old style ipc permissions 523 * 524 * Turn the new style permissions object @in into a compatibility 525 * object and store it into the @out pointer. 526 */ 527 void ipc64_perm_to_ipc_perm(struct ipc64_perm *in, struct ipc_perm *out) 528 { 529 out->key = in->key; 530 SET_UID(out->uid, in->uid); 531 SET_GID(out->gid, in->gid); 532 SET_UID(out->cuid, in->cuid); 533 SET_GID(out->cgid, in->cgid); 534 out->mode = in->mode; 535 out->seq = in->seq; 536 } 537 538 /** 539 * ipc_obtain_object 540 * @ids: ipc identifier set 541 * @id: ipc id to look for 542 * 543 * Look for an id in the ipc ids idr and return associated ipc object. 544 * 545 * Call inside the RCU critical section. 546 * The ipc object is *not* locked on exit. 547 */ 548 struct kern_ipc_perm *ipc_obtain_object_idr(struct ipc_ids *ids, int id) 549 { 550 struct kern_ipc_perm *out; 551 int lid = ipcid_to_idx(id); 552 553 out = idr_find(&ids->ipcs_idr, lid); 554 if (!out) 555 return ERR_PTR(-EINVAL); 556 557 return out; 558 } 559 560 /** 561 * ipc_lock - lock an ipc structure without rwsem held 562 * @ids: ipc identifier set 563 * @id: ipc id to look for 564 * 565 * Look for an id in the ipc ids idr and lock the associated ipc object. 566 * 567 * The ipc object is locked on successful exit. 568 */ 569 struct kern_ipc_perm *ipc_lock(struct ipc_ids *ids, int id) 570 { 571 struct kern_ipc_perm *out; 572 573 rcu_read_lock(); 574 out = ipc_obtain_object_idr(ids, id); 575 if (IS_ERR(out)) 576 goto err; 577 578 spin_lock(&out->lock); 579 580 /* 581 * ipc_rmid() may have already freed the ID while ipc_lock() 582 * was spinning: here verify that the structure is still valid. 583 * Upon races with RMID, return -EIDRM, thus indicating that 584 * the ID points to a removed identifier. 585 */ 586 if (ipc_valid_object(out)) 587 return out; 588 589 spin_unlock(&out->lock); 590 out = ERR_PTR(-EIDRM); 591 err: 592 rcu_read_unlock(); 593 return out; 594 } 595 596 /** 597 * ipc_obtain_object_check 598 * @ids: ipc identifier set 599 * @id: ipc id to look for 600 * 601 * Similar to ipc_obtain_object_idr() but also checks 602 * the ipc object reference counter. 603 * 604 * Call inside the RCU critical section. 605 * The ipc object is *not* locked on exit. 606 */ 607 struct kern_ipc_perm *ipc_obtain_object_check(struct ipc_ids *ids, int id) 608 { 609 struct kern_ipc_perm *out = ipc_obtain_object_idr(ids, id); 610 611 if (IS_ERR(out)) 612 goto out; 613 614 if (ipc_checkid(out, id)) 615 return ERR_PTR(-EINVAL); 616 out: 617 return out; 618 } 619 620 /** 621 * ipcget - Common sys_*get() code 622 * @ns: namespace 623 * @ids: ipc identifier set 624 * @ops: operations to be called on ipc object creation, permission checks 625 * and further checks 626 * @params: the parameters needed by the previous operations. 627 * 628 * Common routine called by sys_msgget(), sys_semget() and sys_shmget(). 629 */ 630 int ipcget(struct ipc_namespace *ns, struct ipc_ids *ids, 631 const struct ipc_ops *ops, struct ipc_params *params) 632 { 633 if (params->key == IPC_PRIVATE) 634 return ipcget_new(ns, ids, ops, params); 635 else 636 return ipcget_public(ns, ids, ops, params); 637 } 638 639 /** 640 * ipc_update_perm - update the permissions of an ipc object 641 * @in: the permission given as input. 642 * @out: the permission of the ipc to set. 643 */ 644 int ipc_update_perm(struct ipc64_perm *in, struct kern_ipc_perm *out) 645 { 646 kuid_t uid = make_kuid(current_user_ns(), in->uid); 647 kgid_t gid = make_kgid(current_user_ns(), in->gid); 648 if (!uid_valid(uid) || !gid_valid(gid)) 649 return -EINVAL; 650 651 out->uid = uid; 652 out->gid = gid; 653 out->mode = (out->mode & ~S_IRWXUGO) 654 | (in->mode & S_IRWXUGO); 655 656 return 0; 657 } 658 659 /** 660 * ipcctl_pre_down_nolock - retrieve an ipc and check permissions for some IPC_XXX cmd 661 * @ns: ipc namespace 662 * @ids: the table of ids where to look for the ipc 663 * @id: the id of the ipc to retrieve 664 * @cmd: the cmd to check 665 * @perm: the permission to set 666 * @extra_perm: one extra permission parameter used by msq 667 * 668 * This function does some common audit and permissions check for some IPC_XXX 669 * cmd and is called from semctl_down, shmctl_down and msgctl_down. 670 * It must be called without any lock held and: 671 * 672 * - retrieves the ipc with the given id in the given table. 673 * - performs some audit and permission check, depending on the given cmd 674 * - returns a pointer to the ipc object or otherwise, the corresponding 675 * error. 676 * 677 * Call holding the both the rwsem and the rcu read lock. 678 */ 679 struct kern_ipc_perm *ipcctl_pre_down_nolock(struct ipc_namespace *ns, 680 struct ipc_ids *ids, int id, int cmd, 681 struct ipc64_perm *perm, int extra_perm) 682 { 683 kuid_t euid; 684 int err = -EPERM; 685 struct kern_ipc_perm *ipcp; 686 687 ipcp = ipc_obtain_object_check(ids, id); 688 if (IS_ERR(ipcp)) { 689 err = PTR_ERR(ipcp); 690 goto err; 691 } 692 693 audit_ipc_obj(ipcp); 694 if (cmd == IPC_SET) 695 audit_ipc_set_perm(extra_perm, perm->uid, 696 perm->gid, perm->mode); 697 698 euid = current_euid(); 699 if (uid_eq(euid, ipcp->cuid) || uid_eq(euid, ipcp->uid) || 700 ns_capable(ns->user_ns, CAP_SYS_ADMIN)) 701 return ipcp; /* successful lookup */ 702 err: 703 return ERR_PTR(err); 704 } 705 706 #ifdef CONFIG_ARCH_WANT_IPC_PARSE_VERSION 707 708 709 /** 710 * ipc_parse_version - ipc call version 711 * @cmd: pointer to command 712 * 713 * Return IPC_64 for new style IPC and IPC_OLD for old style IPC. 714 * The @cmd value is turned from an encoding command and version into 715 * just the command code. 716 */ 717 int ipc_parse_version(int *cmd) 718 { 719 if (*cmd & IPC_64) { 720 *cmd ^= IPC_64; 721 return IPC_64; 722 } else { 723 return IPC_OLD; 724 } 725 } 726 727 #endif /* CONFIG_ARCH_WANT_IPC_PARSE_VERSION */ 728 729 #ifdef CONFIG_PROC_FS 730 struct ipc_proc_iter { 731 struct ipc_namespace *ns; 732 struct ipc_proc_iface *iface; 733 }; 734 735 /* 736 * This routine locks the ipc structure found at least at position pos. 737 */ 738 static struct kern_ipc_perm *sysvipc_find_ipc(struct ipc_ids *ids, loff_t pos, 739 loff_t *new_pos) 740 { 741 struct kern_ipc_perm *ipc; 742 int total, id; 743 744 total = 0; 745 for (id = 0; id < pos && total < ids->in_use; id++) { 746 ipc = idr_find(&ids->ipcs_idr, id); 747 if (ipc != NULL) 748 total++; 749 } 750 751 if (total >= ids->in_use) 752 return NULL; 753 754 for (; pos < IPCMNI; pos++) { 755 ipc = idr_find(&ids->ipcs_idr, pos); 756 if (ipc != NULL) { 757 *new_pos = pos + 1; 758 rcu_read_lock(); 759 ipc_lock_object(ipc); 760 return ipc; 761 } 762 } 763 764 /* Out of range - return NULL to terminate iteration */ 765 return NULL; 766 } 767 768 static void *sysvipc_proc_next(struct seq_file *s, void *it, loff_t *pos) 769 { 770 struct ipc_proc_iter *iter = s->private; 771 struct ipc_proc_iface *iface = iter->iface; 772 struct kern_ipc_perm *ipc = it; 773 774 /* If we had an ipc id locked before, unlock it */ 775 if (ipc && ipc != SEQ_START_TOKEN) 776 ipc_unlock(ipc); 777 778 return sysvipc_find_ipc(&iter->ns->ids[iface->ids], *pos, pos); 779 } 780 781 /* 782 * File positions: pos 0 -> header, pos n -> ipc id = n - 1. 783 * SeqFile iterator: iterator value locked ipc pointer or SEQ_TOKEN_START. 784 */ 785 static void *sysvipc_proc_start(struct seq_file *s, loff_t *pos) 786 { 787 struct ipc_proc_iter *iter = s->private; 788 struct ipc_proc_iface *iface = iter->iface; 789 struct ipc_ids *ids; 790 791 ids = &iter->ns->ids[iface->ids]; 792 793 /* 794 * Take the lock - this will be released by the corresponding 795 * call to stop(). 796 */ 797 down_read(&ids->rwsem); 798 799 /* pos < 0 is invalid */ 800 if (*pos < 0) 801 return NULL; 802 803 /* pos == 0 means header */ 804 if (*pos == 0) 805 return SEQ_START_TOKEN; 806 807 /* Find the (pos-1)th ipc */ 808 return sysvipc_find_ipc(ids, *pos - 1, pos); 809 } 810 811 static void sysvipc_proc_stop(struct seq_file *s, void *it) 812 { 813 struct kern_ipc_perm *ipc = it; 814 struct ipc_proc_iter *iter = s->private; 815 struct ipc_proc_iface *iface = iter->iface; 816 struct ipc_ids *ids; 817 818 /* If we had a locked structure, release it */ 819 if (ipc && ipc != SEQ_START_TOKEN) 820 ipc_unlock(ipc); 821 822 ids = &iter->ns->ids[iface->ids]; 823 /* Release the lock we took in start() */ 824 up_read(&ids->rwsem); 825 } 826 827 static int sysvipc_proc_show(struct seq_file *s, void *it) 828 { 829 struct ipc_proc_iter *iter = s->private; 830 struct ipc_proc_iface *iface = iter->iface; 831 832 if (it == SEQ_START_TOKEN) { 833 seq_puts(s, iface->header); 834 return 0; 835 } 836 837 return iface->show(s, it); 838 } 839 840 static const struct seq_operations sysvipc_proc_seqops = { 841 .start = sysvipc_proc_start, 842 .stop = sysvipc_proc_stop, 843 .next = sysvipc_proc_next, 844 .show = sysvipc_proc_show, 845 }; 846 847 static int sysvipc_proc_open(struct inode *inode, struct file *file) 848 { 849 struct ipc_proc_iter *iter; 850 851 iter = __seq_open_private(file, &sysvipc_proc_seqops, sizeof(*iter)); 852 if (!iter) 853 return -ENOMEM; 854 855 iter->iface = PDE_DATA(inode); 856 iter->ns = get_ipc_ns(current->nsproxy->ipc_ns); 857 858 return 0; 859 } 860 861 static int sysvipc_proc_release(struct inode *inode, struct file *file) 862 { 863 struct seq_file *seq = file->private_data; 864 struct ipc_proc_iter *iter = seq->private; 865 put_ipc_ns(iter->ns); 866 return seq_release_private(inode, file); 867 } 868 869 static const struct file_operations sysvipc_proc_fops = { 870 .open = sysvipc_proc_open, 871 .read = seq_read, 872 .llseek = seq_lseek, 873 .release = sysvipc_proc_release, 874 }; 875 #endif /* CONFIG_PROC_FS */ 876