开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
shm.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：17k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

shm.c：源码内容
  1. /*
  2.  * linux/ipc/shm.c
  3.  * Copyright (C) 1992, 1993 Krishna Balasubramanian
  4.  *  Many improvements/fixes by Bruno Haible.
  5.  * Replaced `struct shm_desc' by `struct vm_area_struct', July 1994.
  6.  * Fixed the shm swap deallocation (shm_unuse()), August 1998 Andrea Arcangeli.
  7.  *
  8.  * /proc/sysvipc/shm support (c) 1999 Dragos Acostachioaie <dragos@iname.com>
  9.  * BIGMEM support, Andrea Arcangeli <andrea@suse.de>
  10.  * SMP thread shm, Jean-Luc Boyard <jean-luc.boyard@siemens.fr>
  11.  * HIGHMEM support, Ingo Molnar <mingo@redhat.com>
  12.  * Make shmmax, shmall, shmmni sysctl'able, Christoph Rohland <cr@sap.com>
  13.  * Shared /dev/zero support, Kanoj Sarcar <kanoj@sgi.com>
  14.  * Move the mm functionality over to mm/shmem.c, Christoph Rohland <cr@sap.com>
  15.  *
  16.  */
  18. #include <linux/config.h>
  19. #include <linux/slab.h>
  20. #include <linux/shm.h>
  21. #include <linux/init.h>
  22. #include <linux/file.h>
  23. #include <linux/mman.h>
  24. #include <linux/proc_fs.h>
  25. #include <asm/uaccess.h>
  27. #include "util.h"
  29. struct shmid_kernel /* private to the kernel */
  30. {
  31. struct kern_ipc_perm shm_perm;
  32. struct file * shm_file;
  33. int id;
  34. unsigned long shm_nattch;
  35. unsigned long shm_segsz;
  36. time_t shm_atim;
  37. time_t shm_dtim;
  38. time_t shm_ctim;
  39. pid_t shm_cprid;
  40. pid_t shm_lprid;
  41. };
  43. #define shm_flags shm_perm.mode
  45. static struct file_operations shm_file_operations;
  46. static struct vm_operations_struct shm_vm_ops;
  48. static struct ipc_ids shm_ids;
  50. #define shm_lock(id) ((struct shmid_kernel*)ipc_lock(&shm_ids,id))
  51. #define shm_unlock(id) ipc_unlock(&shm_ids,id)
  52. #define shm_lockall() ipc_lockall(&shm_ids)
  53. #define shm_unlockall() ipc_unlockall(&shm_ids)
  54. #define shm_get(id) ((struct shmid_kernel*)ipc_get(&shm_ids,id))
  55. #define shm_buildid(id, seq) 
  56. ipc_buildid(&shm_ids, id, seq)
  58. static int newseg (key_t key, int shmflg, size_t size);
  59. static void shm_open (struct vm_area_struct *shmd);
  60. static void shm_close (struct vm_area_struct *shmd);
  61. #ifdef CONFIG_PROC_FS
  62. static int sysvipc_shm_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data);
  63. #endif
  65. size_t shm_ctlmax = SHMMAX;
  66. size_t  shm_ctlall = SHMALL;
  67. int  shm_ctlmni = SHMMNI;
  69. static int shm_tot; /* total number of shared memory pages */
  71. void __init shm_init (void)
  72. {
  73. ipc_init_ids(&shm_ids, 1);
  74. #ifdef CONFIG_PROC_FS
  75. create_proc_read_entry("sysvipc/shm", 0, 0, sysvipc_shm_read_proc, NULL);
  76. #endif
  77. }
  79. static inline int shm_checkid(struct shmid_kernel *s, int id)
  80. {
  81. if (ipc_checkid(&shm_ids,&s->shm_perm,id))
  82. return -EIDRM;
  83. return 0;
  84. }
  86. static inline struct shmid_kernel *shm_rmid(int id)
  87. {
  88. return (struct shmid_kernel *)ipc_rmid(&shm_ids,id);
  89. }
  91. static inline int shm_addid(struct shmid_kernel *shp)
  92. {
  93. return ipc_addid(&shm_ids, &shp->shm_perm, shm_ctlmni+1);
  94. }
  98. static inline void shm_inc (int id) {
  99. struct shmid_kernel *shp;
  101. if(!(shp = shm_lock(id)))
  102. BUG();
  103. shp->shm_atim = CURRENT_TIME;
  104. shp->shm_lprid = current->pid;
  105. shp->shm_nattch++;
  106. shm_unlock(id);
  107. }
  109. /* This is called by fork, once for every shm attach. */
  110. static void shm_open (struct vm_area_struct *shmd)
  111. {
  112. shm_inc (shmd->vm_file->f_dentry->d_inode->i_ino);
  113. }
  115. /*
  116.  * shm_destroy - free the struct shmid_kernel
  117.  *
  118.  * @shp: struct to free
  119.  *
  120.  * It has to be called with shp and shm_ids.sem locked,
  121.  * but returns with shp unlocked and freed.
  122.  */
  123. static void shm_destroy (struct shmid_kernel *shp)
  124. {
  125. shm_tot -= (shp->shm_segsz + PAGE_SIZE - 1) >> PAGE_SHIFT;
  126. shm_rmid (shp->id);
  127. shm_unlock(shp->id);
  128. shmem_lock(shp->shm_file, 0);
  129. fput (shp->shm_file);
  130. kfree (shp);
  131. }
  133. /*
  134.  * remove the attach descriptor shmd.
  135.  * free memory for segment if it is marked destroyed.
  136.  * The descriptor has already been removed from the current->mm->mmap list
  137.  * and will later be kfree()d.
  138.  */
  139. static void shm_close (struct vm_area_struct *shmd)
  140. {
  141. struct file * file = shmd->vm_file;
  142. int id = file->f_dentry->d_inode->i_ino;
  143. struct shmid_kernel *shp;
  145. down (&shm_ids.sem);
  146. /* remove from the list of attaches of the shm segment */
  147. if(!(shp = shm_lock(id)))
  148. BUG();
  149. shp->shm_lprid = current->pid;
  150. shp->shm_dtim = CURRENT_TIME;
  151. shp->shm_nattch--;
  152. if(shp->shm_nattch == 0 &&
  153.    shp->shm_flags & SHM_DEST)
  154. shm_destroy (shp);
  155. else
  156. shm_unlock(id);
  157. up (&shm_ids.sem);
  158. }
  160. static int shm_mmap(struct file * file, struct vm_area_struct * vma)
  161. {
  162. UPDATE_ATIME(file->f_dentry->d_inode);
  163. vma->vm_ops = &shm_vm_ops;
  164. shm_inc(file->f_dentry->d_inode->i_ino);
  165. return 0;
  166. }
  168. static struct file_operations shm_file_operations = {
  169. mmap: shm_mmap
  170. };
  172. static struct vm_operations_struct shm_vm_ops = {
  173. open: shm_open, /* callback for a new vm-area open */
  174. close: shm_close, /* callback for when the vm-area is released */
  175. nopage: shmem_nopage,
  176. };
  178. static int newseg (key_t key, int shmflg, size_t size)
  179. {
  180. int error;
  181. struct shmid_kernel *shp;
  182. int numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
  183. struct file * file;
  184. char name[13];
  185. int id;
  187. if (size < SHMMIN || size > shm_ctlmax)
  188. return -EINVAL;
  190. if (shm_tot + numpages >= shm_ctlall)
  191. return -ENOSPC;
  193. shp = (struct shmid_kernel *) kmalloc (sizeof (*shp), GFP_USER);
  194. if (!shp)
  195. return -ENOMEM;
  196. sprintf (name, "SYSV%08x", key);
  197. file = shmem_file_setup(name, size);
  198. error = PTR_ERR(file);
  199. if (IS_ERR(file))
  200. goto no_file;
  202. error = -ENOSPC;
  203. id = shm_addid(shp);
  204. if(id == -1) 
  205. goto no_id;
  206. shp->shm_perm.key = key;
  207. shp->shm_flags = (shmflg & S_IRWXUGO);
  208. shp->shm_cprid = current->pid;
  209. shp->shm_lprid = 0;
  210. shp->shm_atim = shp->shm_dtim = 0;
  211. shp->shm_ctim = CURRENT_TIME;
  212. shp->shm_segsz = size;
  213. shp->shm_nattch = 0;
  214. shp->id = shm_buildid(id,shp->shm_perm.seq);
  215. shp->shm_file = file;
  216. file->f_dentry->d_inode->i_ino = shp->id;
  217. file->f_op = &shm_file_operations;
  218. shm_tot += numpages;
  219. shm_unlock (id);
  220. return shp->id;
  222. no_id:
  223. fput(file);
  224. no_file:
  225. kfree(shp);
  226. return error;
  227. }
  229. asmlinkage long sys_shmget (key_t key, size_t size, int shmflg)
  230. {
  231. struct shmid_kernel *shp;
  232. int err, id = 0;
  234. down(&shm_ids.sem);
  235. if (key == IPC_PRIVATE) {
  236. err = newseg(key, shmflg, size);
  237. } else if ((id = ipc_findkey(&shm_ids, key)) == -1) {
  238. if (!(shmflg & IPC_CREAT))
  239. err = -ENOENT;
  240. else
  241. err = newseg(key, shmflg, size);
  242. } else if ((shmflg & IPC_CREAT) && (shmflg & IPC_EXCL)) {
  243. err = -EEXIST;
  244. } else {
  245. shp = shm_lock(id);
  246. if(shp==NULL)
  247. BUG();
  248. if (shp->shm_segsz < size)
  249. err = -EINVAL;
  250. else if (ipcperms(&shp->shm_perm, shmflg))
  251. err = -EACCES;
  252. else
  253. err = shm_buildid(id, shp->shm_perm.seq);
  254. shm_unlock(id);
  255. }
  256. up(&shm_ids.sem);
  257. return err;
  258. }
  260. static inline unsigned long copy_shmid_to_user(void *buf, struct shmid64_ds *in, int version)
  261. {
  262. switch(version) {
  263. case IPC_64:
  264. return copy_to_user(buf, in, sizeof(*in));
  265. case IPC_OLD:
  266.     {
  267. struct shmid_ds out;
  269. ipc64_perm_to_ipc_perm(&in->shm_perm, &out.shm_perm);
  270. out.shm_segsz = in->shm_segsz;
  271. out.shm_atime = in->shm_atime;
  272. out.shm_dtime = in->shm_dtime;
  273. out.shm_ctime = in->shm_ctime;
  274. out.shm_cpid = in->shm_cpid;
  275. out.shm_lpid = in->shm_lpid;
  276. out.shm_nattch = in->shm_nattch;
  278. return copy_to_user(buf, &out, sizeof(out));
  279.     }
  280. default:
  281. return -EINVAL;
  282. }
  283. }
  285. struct shm_setbuf {
  286. uid_t uid;
  287. gid_t gid;
  288. mode_t mode;
  289. };
  291. static inline unsigned long copy_shmid_from_user(struct shm_setbuf *out, void *buf, int version)
  292. {
  293. switch(version) {
  294. case IPC_64:
  295.     {
  296. struct shmid64_ds tbuf;
  298. if (copy_from_user(&tbuf, buf, sizeof(tbuf)))
  299. return -EFAULT;
  301. out->uid = tbuf.shm_perm.uid;
  302. out->gid = tbuf.shm_perm.gid;
  303. out->mode = tbuf.shm_flags;
  305. return 0;
  306.     }
  307. case IPC_OLD:
  308.     {
  309. struct shmid_ds tbuf_old;
  311. if (copy_from_user(&tbuf_old, buf, sizeof(tbuf_old)))
  312. return -EFAULT;
  314. out->uid = tbuf_old.shm_perm.uid;
  315. out->gid = tbuf_old.shm_perm.gid;
  316. out->mode = tbuf_old.shm_flags;
  318. return 0;
  319.     }
  320. default:
  321. return -EINVAL;
  322. }
  323. }
  325. static inline unsigned long copy_shminfo_to_user(void *buf, struct shminfo64 *in, int version)
  326. {
  327. switch(version) {
  328. case IPC_64:
  329. return copy_to_user(buf, in, sizeof(*in));
  330. case IPC_OLD:
  331.     {
  332. struct shminfo out;
  334. if(in->shmmax > INT_MAX)
  335. out.shmmax = INT_MAX;
  336. else
  337. out.shmmax = (int)in->shmmax;
  339. out.shmmin = in->shmmin;
  340. out.shmmni = in->shmmni;
  341. out.shmseg = in->shmseg;
  342. out.shmall = in->shmall; 
  344. return copy_to_user(buf, &out, sizeof(out));
  345.     }
  346. default:
  347. return -EINVAL;
  348. }
  349. }
  351. static void shm_get_stat (unsigned long *rss, unsigned long *swp) 
  352. {
  353. struct shmem_inode_info *info;
  354. int i;
  356. *rss = 0;
  357. *swp = 0;
  359. for(i = 0; i <= shm_ids.max_id; i++) {
  360. struct shmid_kernel* shp;
  361. struct inode * inode;
  363. shp = shm_get(i);
  364. if(shp == NULL)
  365. continue;
  366. inode = shp->shm_file->f_dentry->d_inode;
  367. info = SHMEM_I(inode);
  368. spin_lock (&info->lock);
  369. *rss += inode->i_mapping->nrpages;
  370. *swp += info->swapped;
  371. spin_unlock (&info->lock);
  372. }
  373. }
  375. asmlinkage long sys_shmctl (int shmid, int cmd, struct shmid_ds *buf)
  376. {
  377. struct shm_setbuf setbuf;
  378. struct shmid_kernel *shp;
  379. int err, version;
  381. if (cmd < 0 || shmid < 0)
  382. return -EINVAL;
  384. version = ipc_parse_version(&cmd);
  386. switch (cmd) { /* replace with proc interface ? */
  387. case IPC_INFO:
  388. {
  389. struct shminfo64 shminfo;
  391. memset(&shminfo,0,sizeof(shminfo));
  392. shminfo.shmmni = shminfo.shmseg = shm_ctlmni;
  393. shminfo.shmmax = shm_ctlmax;
  394. shminfo.shmall = shm_ctlall;
  396. shminfo.shmmin = SHMMIN;
  397. if(copy_shminfo_to_user (buf, &shminfo, version))
  398. return -EFAULT;
  399. /* reading a integer is always atomic */
  400. err= shm_ids.max_id;
  401. if(err<0)
  402. err = 0;
  403. return err;
  404. }
  405. case SHM_INFO:
  406. {
  407. struct shm_info shm_info;
  409. memset(&shm_info,0,sizeof(shm_info));
  410. down(&shm_ids.sem);
  411. shm_lockall();
  412. shm_info.used_ids = shm_ids.in_use;
  413. shm_get_stat (&shm_info.shm_rss, &shm_info.shm_swp);
  414. shm_info.shm_tot = shm_tot;
  415. shm_info.swap_attempts = 0;
  416. shm_info.swap_successes = 0;
  417. err = shm_ids.max_id;
  418. shm_unlockall();
  419. up(&shm_ids.sem);
  420. if(copy_to_user (buf, &shm_info, sizeof(shm_info)))
  421. return -EFAULT;
  423. return err < 0 ? 0 : err;
  424. }
  425. case SHM_STAT:
  426. case IPC_STAT:
  427. {
  428. struct shmid64_ds tbuf;
  429. int result;
  430. memset(&tbuf, 0, sizeof(tbuf));
  431. shp = shm_lock(shmid);
  432. if(shp==NULL)
  433. return -EINVAL;
  434. if(cmd==SHM_STAT) {
  435. err = -EINVAL;
  436. if (shmid > shm_ids.max_id)
  437. goto out_unlock;
  438. result = shm_buildid(shmid, shp->shm_perm.seq);
  439. } else {
  440. err = shm_checkid(shp,shmid);
  441. if(err)
  442. goto out_unlock;
  443. result = 0;
  444. }
  445. err=-EACCES;
  446. if (ipcperms (&shp->shm_perm, S_IRUGO))
  447. goto out_unlock;
  448. kernel_to_ipc64_perm(&shp->shm_perm, &tbuf.shm_perm);
  449. tbuf.shm_segsz = shp->shm_segsz;
  450. tbuf.shm_atime = shp->shm_atim;
  451. tbuf.shm_dtime = shp->shm_dtim;
  452. tbuf.shm_ctime = shp->shm_ctim;
  453. tbuf.shm_cpid = shp->shm_cprid;
  454. tbuf.shm_lpid = shp->shm_lprid;
  455. tbuf.shm_nattch = shp->shm_nattch;
  456. shm_unlock(shmid);
  457. if(copy_shmid_to_user (buf, &tbuf, version))
  458. return -EFAULT;
  459. return result;
  460. }
  461. case SHM_LOCK:
  462. case SHM_UNLOCK:
  463. {
  464. /* Allow superuser to lock segment in memory */
  465. /* Should the pages be faulted in here or leave it to user? */
  466. /* need to determine interaction with current->swappable */
  467. if (!capable(CAP_IPC_LOCK))
  468. return -EPERM;
  470. shp = shm_lock(shmid);
  471. if(shp==NULL)
  472. return -EINVAL;
  473. err = shm_checkid(shp,shmid);
  474. if(err)
  475. goto out_unlock;
  476. if(cmd==SHM_LOCK) {
  477. shmem_lock(shp->shm_file, 1);
  478. shp->shm_flags |= SHM_LOCKED;
  479. } else {
  480. shmem_lock(shp->shm_file, 0);
  481. shp->shm_flags &= ~SHM_LOCKED;
  482. }
  483. shm_unlock(shmid);
  484. return err;
  485. }
  486. case IPC_RMID:
  487. {
  488. /*
  489.  * We cannot simply remove the file. The SVID states
  490.  * that the block remains until the last person
  491.  * detaches from it, then is deleted. A shmat() on
  492.  * an RMID segment is legal in older Linux and if 
  493.  * we change it apps break...
  494.  *
  495.  * Instead we set a destroyed flag, and then blow
  496.  * the name away when the usage hits zero.
  497.  */
  498. down(&shm_ids.sem);
  499. shp = shm_lock(shmid);
  500. err = -EINVAL;
  501. if (shp == NULL) 
  502. goto out_up;
  503. err = shm_checkid(shp, shmid);
  504. if(err)
  505. goto out_unlock_up;
  506. if (current->euid != shp->shm_perm.uid &&
  507.     current->euid != shp->shm_perm.cuid && 
  508.     !capable(CAP_SYS_ADMIN)) {
  509. err=-EPERM;
  510. goto out_unlock_up;
  511. }
  512. if (shp->shm_nattch){
  513. shp->shm_flags |= SHM_DEST;
  514. /* Do not find it any more */
  515. shp->shm_perm.key = IPC_PRIVATE;
  516. shm_unlock(shmid);
  517. } else
  518. shm_destroy (shp);
  519. up(&shm_ids.sem);
  520. return err;
  521. }
  523. case IPC_SET:
  524. {
  525. if(copy_shmid_from_user (&setbuf, buf, version))
  526. return -EFAULT;
  527. down(&shm_ids.sem);
  528. shp = shm_lock(shmid);
  529. err=-EINVAL;
  530. if(shp==NULL)
  531. goto out_up;
  532. err = shm_checkid(shp,shmid);
  533. if(err)
  534. goto out_unlock_up;
  535. err=-EPERM;
  536. if (current->euid != shp->shm_perm.uid &&
  537.     current->euid != shp->shm_perm.cuid && 
  538.     !capable(CAP_SYS_ADMIN)) {
  539. goto out_unlock_up;
  540. }
  542. shp->shm_perm.uid = setbuf.uid;
  543. shp->shm_perm.gid = setbuf.gid;
  544. shp->shm_flags = (shp->shm_flags & ~S_IRWXUGO)
  545. | (setbuf.mode & S_IRWXUGO);
  546. shp->shm_ctim = CURRENT_TIME;
  547. break;
  548. }
  550. default:
  551. return -EINVAL;
  552. }
  554. err = 0;
  555. out_unlock_up:
  556. shm_unlock(shmid);
  557. out_up:
  558. up(&shm_ids.sem);
  559. return err;
  560. out_unlock:
  561. shm_unlock(shmid);
  562. return err;
  563. }
  565. /*
  566.  * Fix shmaddr, allocate descriptor, map shm, add attach descriptor to lists.
  567.  */
  568. asmlinkage long sys_shmat (int shmid, char *shmaddr, int shmflg, ulong *raddr)
  569. {
  570. struct shmid_kernel *shp;
  571. unsigned long addr;
  572. unsigned long size;
  573. struct file * file;
  574. int    err;
  575. unsigned long flags;
  576. unsigned long prot;
  577. unsigned long o_flags;
  578. int acc_mode;
  579. void *user_addr;
  581. if (shmid < 0)
  582. return -EINVAL;
  584. if ((addr = (ulong)shmaddr)) {
  585. if (addr & (SHMLBA-1)) {
  586. if (shmflg & SHM_RND)
  587. addr &= ~(SHMLBA-1);    /* round down */
  588. else
  589. return -EINVAL;
  590. }
  591. flags = MAP_SHARED | MAP_FIXED;
  592. } else {
  593. if ((shmflg & SHM_REMAP))
  594. return -EINVAL;
  596. flags = MAP_SHARED;
  597. }
  599. if (shmflg & SHM_RDONLY) {
  600. prot = PROT_READ;
  601. o_flags = O_RDONLY;
  602. acc_mode = S_IRUGO;
  603. } else {
  604. prot = PROT_READ | PROT_WRITE;
  605. o_flags = O_RDWR;
  606. acc_mode = S_IRUGO | S_IWUGO;
  607. }
  609. /*
  610.  * We cannot rely on the fs check since SYSV IPC does have an
  611.  * additional creator id...
  612.  */
  613. shp = shm_lock(shmid);
  614. if(shp == NULL)
  615. return -EINVAL;
  616. err = shm_checkid(shp,shmid);
  617. if (err) {
  618. shm_unlock(shmid);
  619. return err;
  620. }
  621. if (ipcperms(&shp->shm_perm, acc_mode)) {
  622. shm_unlock(shmid);
  623. return -EACCES;
  624. }
  625. file = shp->shm_file;
  626. size = file->f_dentry->d_inode->i_size;
  627. shp->shm_nattch++;
  628. shm_unlock(shmid);
  630. down_write(&current->mm->mmap_sem);
  631. if (addr && !(shmflg & SHM_REMAP)) {
  632. user_addr = ERR_PTR(-EINVAL);
  633. if (find_vma_intersection(current->mm, addr, addr + size))
  634. goto invalid;
  635. /*
  636.  * If shm segment goes below stack, make sure there is some
  637.  * space left for the stack to grow (at least 4 pages).
  638.  */
  639. if (addr < current->mm->start_stack &&
  640.     addr > current->mm->start_stack - size - PAGE_SIZE * 5)
  641. goto invalid;
  642. }
  644. user_addr = (void*) do_mmap (file, addr, size, prot, flags, 0);
  646. invalid:
  647. up_write(&current->mm->mmap_sem);
  649. down (&shm_ids.sem);
  650. if(!(shp = shm_lock(shmid)))
  651. BUG();
  652. shp->shm_nattch--;
  653. if(shp->shm_nattch == 0 &&
  654.    shp->shm_flags & SHM_DEST)
  655. shm_destroy (shp);
  656. else
  657. shm_unlock(shmid);
  658. up (&shm_ids.sem);
  660. *raddr = (unsigned long) user_addr;
  661. err = 0;
  662. if (IS_ERR(user_addr))
  663. err = PTR_ERR(user_addr);
  664. return err;
  666. }
  668. /*
  669.  * detach and kill segment if marked destroyed.
  670.  * The work is done in shm_close.
  671.  */
  672. asmlinkage long sys_shmdt (char *shmaddr)
  673. {
  674. struct mm_struct *mm = current->mm;
  675. struct vm_area_struct *shmd, *shmdnext;
  676. int retval = -EINVAL;
  678. down_write(&mm->mmap_sem);
  679. for (shmd = mm->mmap; shmd; shmd = shmdnext) {
  680. shmdnext = shmd->vm_next;
  681. if (shmd->vm_ops == &shm_vm_ops
  682.     && shmd->vm_start - (shmd->vm_pgoff << PAGE_SHIFT) == (ulong) shmaddr) {
  683. do_munmap(mm, shmd->vm_start, shmd->vm_end - shmd->vm_start);
  684. retval = 0;
  685. }
  686. }
  687. up_write(&mm->mmap_sem);
  688. return retval;
  689. }
  691. #ifdef CONFIG_PROC_FS
  692. static int sysvipc_shm_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data)
  693. {
  694. off_t pos = 0;
  695. off_t begin = 0;
  696. int i, len = 0;
  698. down(&shm_ids.sem);
  699. len += sprintf(buffer, "       key      shmid perms       size  cpid  lpid nattch   uid   gid  cuid  cgid      atime      dtime      ctimen");
  701. for(i = 0; i <= shm_ids.max_id; i++) {
  702. struct shmid_kernel* shp;
  704. shp = shm_lock(i);
  705. if(shp!=NULL) {
  706. #define SMALL_STRING "%10d %10d  %4o %10u %5u %5u  %5d %5u %5u %5u %5u %10lu %10lu %10lun"
  707. #define BIG_STRING   "%10d %10d  %4o %21u %5u %5u  %5d %5u %5u %5u %5u %10lu %10lu %10lun"
  708. char *format;
  710. if (sizeof(size_t) <= sizeof(int))
  711. format = SMALL_STRING;
  712. else
  713. format = BIG_STRING;
  714. len += sprintf(buffer + len, format,
  715. shp->shm_perm.key,
  716. shm_buildid(i, shp->shm_perm.seq),
  717. shp->shm_flags,
  718. shp->shm_segsz,
  719. shp->shm_cprid,
  720. shp->shm_lprid,
  721. shp->shm_nattch,
  722. shp->shm_perm.uid,
  723. shp->shm_perm.gid,
  724. shp->shm_perm.cuid,
  725. shp->shm_perm.cgid,
  726. shp->shm_atim,
  727. shp->shm_dtim,
  728. shp->shm_ctim);
  729. shm_unlock(i);
  731. pos += len;
  732. if(pos < offset) {
  733. len = 0;
  734. begin = pos;
  735. }
  736. if(pos > offset + length)
  737. goto done;
  738. }
  739. }
  740. *eof = 1;
  741. done:
  742. up(&shm_ids.sem);
  743. *start = buffer + (offset - begin);
  744. len -= (offset - begin);
  745. if(len > length)
  746. len = length;
  747. if(len < 0)
  748. len = 0;
  749. return len;
  750. }
  751. #endif