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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
shm.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：17k
源码类别：

嵌入式Linux

开发平台：

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.  */
  122. static void shm_destroy (struct shmid_kernel *shp)
  123. {
  124. shm_tot -= (shp->shm_segsz + PAGE_SIZE - 1) >> PAGE_SHIFT;
  125. shm_rmid (shp->id);
  126. shmem_lock(shp->shm_file, 0);
  127. fput (shp->shm_file);
  128. kfree (shp);
  129. }
  131. /*
  132.  * remove the attach descriptor shmd.
  133.  * free memory for segment if it is marked destroyed.
  134.  * The descriptor has already been removed from the current->mm->mmap list
  135.  * and will later be kfree()d.
  136.  */
  137. static void shm_close (struct vm_area_struct *shmd)
  138. {
  139. struct file * file = shmd->vm_file;
  140. int id = file->f_dentry->d_inode->i_ino;
  141. struct shmid_kernel *shp;
  143. down (&shm_ids.sem);
  144. /* remove from the list of attaches of the shm segment */
  145. if(!(shp = shm_lock(id)))
  146. BUG();
  147. shp->shm_lprid = current->pid;
  148. shp->shm_dtim = CURRENT_TIME;
  149. shp->shm_nattch--;
  150. if(shp->shm_nattch == 0 &&
  151.    shp->shm_flags & SHM_DEST)
  152. shm_destroy (shp);
  154. shm_unlock(id);
  155. up (&shm_ids.sem);
  156. }
  158. static int shm_mmap(struct file * file, struct vm_area_struct * vma)
  159. {
  160. UPDATE_ATIME(file->f_dentry->d_inode);
  161. vma->vm_ops = &shm_vm_ops;
  162. shm_inc(file->f_dentry->d_inode->i_ino);
  163. return 0;
  164. }
  166. static struct file_operations shm_file_operations = {
  167. mmap: shm_mmap
  168. };
  170. static struct vm_operations_struct shm_vm_ops = {
  171. open: shm_open, /* callback for a new vm-area open */
  172. close: shm_close, /* callback for when the vm-area is released */
  173. nopage: shmem_nopage,
  174. };
  176. static int newseg (key_t key, int shmflg, size_t size)
  177. {
  178. int error;
  179. struct shmid_kernel *shp;
  180. int numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
  181. struct file * file;
  182. char name[13];
  183. int id;
  185. if (size < SHMMIN || size > shm_ctlmax)
  186. return -EINVAL;
  188. if (shm_tot + numpages >= shm_ctlall)
  189. return -ENOSPC;
  191. shp = (struct shmid_kernel *) kmalloc (sizeof (*shp), GFP_USER);
  192. if (!shp)
  193. return -ENOMEM;
  194. sprintf (name, "SYSV%08x", key);
  195. file = shmem_file_setup(name, size);
  196. error = PTR_ERR(file);
  197. if (IS_ERR(file))
  198. goto no_file;
  200. error = -ENOSPC;
  201. id = shm_addid(shp);
  202. if(id == -1) 
  203. goto no_id;
  204. shp->shm_perm.key = key;
  205. shp->shm_flags = (shmflg & S_IRWXUGO);
  206. shp->shm_cprid = current->pid;
  207. shp->shm_lprid = 0;
  208. shp->shm_atim = shp->shm_dtim = 0;
  209. shp->shm_ctim = CURRENT_TIME;
  210. shp->shm_segsz = size;
  211. shp->shm_nattch = 0;
  212. shp->id = shm_buildid(id,shp->shm_perm.seq);
  213. shp->shm_file = file;
  214. file->f_dentry->d_inode->i_ino = shp->id;
  215. file->f_op = &shm_file_operations;
  216. shm_tot += numpages;
  217. shm_unlock (id);
  218. return shp->id;
  220. no_id:
  221. fput(file);
  222. no_file:
  223. kfree(shp);
  224. return error;
  225. }
  227. asmlinkage long sys_shmget (key_t key, size_t size, int shmflg)
  228. {
  229. struct shmid_kernel *shp;
  230. int err, id = 0;
  232. down(&shm_ids.sem);
  233. if (key == IPC_PRIVATE) {
  234. err = newseg(key, shmflg, size);
  235. } else if ((id = ipc_findkey(&shm_ids, key)) == -1) {
  236. if (!(shmflg & IPC_CREAT))
  237. err = -ENOENT;
  238. else
  239. err = newseg(key, shmflg, size);
  240. } else if ((shmflg & IPC_CREAT) && (shmflg & IPC_EXCL)) {
  241. err = -EEXIST;
  242. } else {
  243. shp = shm_lock(id);
  244. if(shp==NULL)
  245. BUG();
  246. if (shp->shm_segsz < size)
  247. err = -EINVAL;
  248. else if (ipcperms(&shp->shm_perm, shmflg))
  249. err = -EACCES;
  250. else
  251. err = shm_buildid(id, shp->shm_perm.seq);
  252. shm_unlock(id);
  253. }
  254. up(&shm_ids.sem);
  255. return err;
  256. }
  258. static inline unsigned long copy_shmid_to_user(void *buf, struct shmid64_ds *in, int version)
  259. {
  260. switch(version) {
  261. case IPC_64:
  262. return copy_to_user(buf, in, sizeof(*in));
  263. case IPC_OLD:
  264.     {
  265. struct shmid_ds out;
  267. ipc64_perm_to_ipc_perm(&in->shm_perm, &out.shm_perm);
  268. out.shm_segsz = in->shm_segsz;
  269. out.shm_atime = in->shm_atime;
  270. out.shm_dtime = in->shm_dtime;
  271. out.shm_ctime = in->shm_ctime;
  272. out.shm_cpid = in->shm_cpid;
  273. out.shm_lpid = in->shm_lpid;
  274. out.shm_nattch = in->shm_nattch;
  276. return copy_to_user(buf, &out, sizeof(out));
  277.     }
  278. default:
  279. return -EINVAL;
  280. }
  281. }
  283. struct shm_setbuf {
  284. uid_t uid;
  285. gid_t gid;
  286. mode_t mode;
  287. };
  289. static inline unsigned long copy_shmid_from_user(struct shm_setbuf *out, void *buf, int version)
  290. {
  291. switch(version) {
  292. case IPC_64:
  293.     {
  294. struct shmid64_ds tbuf;
  296. if (copy_from_user(&tbuf, buf, sizeof(tbuf)))
  297. return -EFAULT;
  299. out->uid = tbuf.shm_perm.uid;
  300. out->gid = tbuf.shm_perm.gid;
  301. out->mode = tbuf.shm_flags;
  303. return 0;
  304.     }
  305. case IPC_OLD:
  306.     {
  307. struct shmid_ds tbuf_old;
  309. if (copy_from_user(&tbuf_old, buf, sizeof(tbuf_old)))
  310. return -EFAULT;
  312. out->uid = tbuf_old.shm_perm.uid;
  313. out->gid = tbuf_old.shm_perm.gid;
  314. out->mode = tbuf_old.shm_flags;
  316. return 0;
  317.     }
  318. default:
  319. return -EINVAL;
  320. }
  321. }
  323. static inline unsigned long copy_shminfo_to_user(void *buf, struct shminfo64 *in, int version)
  324. {
  325. switch(version) {
  326. case IPC_64:
  327. return copy_to_user(buf, in, sizeof(*in));
  328. case IPC_OLD:
  329.     {
  330. struct shminfo out;
  332. if(in->shmmax > INT_MAX)
  333. out.shmmax = INT_MAX;
  334. else
  335. out.shmmax = (int)in->shmmax;
  337. out.shmmin = in->shmmin;
  338. out.shmmni = in->shmmni;
  339. out.shmseg = in->shmseg;
  340. out.shmall = in->shmall; 
  342. return copy_to_user(buf, &out, sizeof(out));
  343.     }
  344. default:
  345. return -EINVAL;
  346. }
  347. }
  349. static void shm_get_stat (unsigned long *rss, unsigned long *swp) 
  350. {
  351. struct shmem_inode_info *info;
  352. int i;
  354. *rss = 0;
  355. *swp = 0;
  357. for(i = 0; i <= shm_ids.max_id; i++) {
  358. struct shmid_kernel* shp;
  359. struct inode * inode;
  361. shp = shm_get(i);
  362. if(shp == NULL)
  363. continue;
  364. inode = shp->shm_file->f_dentry->d_inode;
  365. info = SHMEM_I(inode);
  366. spin_lock (&info->lock);
  367. *rss += inode->i_mapping->nrpages;
  368. *swp += info->swapped;
  369. spin_unlock (&info->lock);
  370. }
  371. }
  373. asmlinkage long sys_shmctl (int shmid, int cmd, struct shmid_ds *buf)
  374. {
  375. struct shm_setbuf setbuf;
  376. struct shmid_kernel *shp;
  377. int err, version;
  379. if (cmd < 0 || shmid < 0)
  380. return -EINVAL;
  382. version = ipc_parse_version(&cmd);
  384. switch (cmd) { /* replace with proc interface ? */
  385. case IPC_INFO:
  386. {
  387. struct shminfo64 shminfo;
  389. memset(&shminfo,0,sizeof(shminfo));
  390. shminfo.shmmni = shminfo.shmseg = shm_ctlmni;
  391. shminfo.shmmax = shm_ctlmax;
  392. shminfo.shmall = shm_ctlall;
  394. shminfo.shmmin = SHMMIN;
  395. if(copy_shminfo_to_user (buf, &shminfo, version))
  396. return -EFAULT;
  397. /* reading a integer is always atomic */
  398. err= shm_ids.max_id;
  399. if(err<0)
  400. err = 0;
  401. return err;
  402. }
  403. case SHM_INFO:
  404. {
  405. struct shm_info shm_info;
  407. memset(&shm_info,0,sizeof(shm_info));
  408. down(&shm_ids.sem);
  409. shm_lockall();
  410. shm_info.used_ids = shm_ids.in_use;
  411. shm_get_stat (&shm_info.shm_rss, &shm_info.shm_swp);
  412. shm_info.shm_tot = shm_tot;
  413. shm_info.swap_attempts = 0;
  414. shm_info.swap_successes = 0;
  415. err = shm_ids.max_id;
  416. shm_unlockall();
  417. up(&shm_ids.sem);
  418. if(copy_to_user (buf, &shm_info, sizeof(shm_info)))
  419. return -EFAULT;
  421. return err < 0 ? 0 : err;
  422. }
  423. case SHM_STAT:
  424. case IPC_STAT:
  425. {
  426. struct shmid64_ds tbuf;
  427. int result;
  428. memset(&tbuf, 0, sizeof(tbuf));
  429. shp = shm_lock(shmid);
  430. if(shp==NULL)
  431. return -EINVAL;
  432. if(cmd==SHM_STAT) {
  433. err = -EINVAL;
  434. if (shmid > shm_ids.max_id)
  435. goto out_unlock;
  436. result = shm_buildid(shmid, shp->shm_perm.seq);
  437. } else {
  438. err = shm_checkid(shp,shmid);
  439. if(err)
  440. goto out_unlock;
  441. result = 0;
  442. }
  443. err=-EACCES;
  444. if (ipcperms (&shp->shm_perm, S_IRUGO))
  445. goto out_unlock;
  446. kernel_to_ipc64_perm(&shp->shm_perm, &tbuf.shm_perm);
  447. tbuf.shm_segsz = shp->shm_segsz;
  448. tbuf.shm_atime = shp->shm_atim;
  449. tbuf.shm_dtime = shp->shm_dtim;
  450. tbuf.shm_ctime = shp->shm_ctim;
  451. tbuf.shm_cpid = shp->shm_cprid;
  452. tbuf.shm_lpid = shp->shm_lprid;
  453. tbuf.shm_nattch = shp->shm_nattch;
  454. shm_unlock(shmid);
  455. if(copy_shmid_to_user (buf, &tbuf, version))
  456. return -EFAULT;
  457. return result;
  458. }
  459. case SHM_LOCK:
  460. case SHM_UNLOCK:
  461. {
  462. /* Allow superuser to lock segment in memory */
  463. /* Should the pages be faulted in here or leave it to user? */
  464. /* need to determine interaction with current->swappable */
  465. if (!capable(CAP_IPC_LOCK))
  466. return -EPERM;
  468. shp = shm_lock(shmid);
  469. if(shp==NULL)
  470. return -EINVAL;
  471. err = shm_checkid(shp,shmid);
  472. if(err)
  473. goto out_unlock;
  474. if(cmd==SHM_LOCK) {
  475. shmem_lock(shp->shm_file, 1);
  476. shp->shm_flags |= SHM_LOCKED;
  477. } else {
  478. shmem_lock(shp->shm_file, 0);
  479. shp->shm_flags &= ~SHM_LOCKED;
  480. }
  481. shm_unlock(shmid);
  482. return err;
  483. }
  484. case IPC_RMID:
  485. {
  486. /*
  487.  * We cannot simply remove the file. The SVID states
  488.  * that the block remains until the last person
  489.  * detaches from it, then is deleted. A shmat() on
  490.  * an RMID segment is legal in older Linux and if 
  491.  * we change it apps break...
  492.  *
  493.  * Instead we set a destroyed flag, and then blow
  494.  * the name away when the usage hits zero.
  495.  */
  496. down(&shm_ids.sem);
  497. shp = shm_lock(shmid);
  498. err = -EINVAL;
  499. if (shp == NULL) 
  500. goto out_up;
  501. err = shm_checkid(shp, shmid);
  502. if(err)
  503. goto out_unlock_up;
  504. if (current->euid != shp->shm_perm.uid &&
  505.     current->euid != shp->shm_perm.cuid && 
  506.     !capable(CAP_SYS_ADMIN)) {
  507. err=-EPERM;
  508. goto out_unlock_up;
  509. }
  510. if (shp->shm_nattch){
  511. shp->shm_flags |= SHM_DEST;
  512. /* Do not find it any more */
  513. shp->shm_perm.key = IPC_PRIVATE;
  514. } else
  515. shm_destroy (shp);
  517. /* Unlock */
  518. shm_unlock(shmid);
  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. shm_unlock(shmid);
  657. up (&shm_ids.sem);
  659. *raddr = (unsigned long) user_addr;
  660. err = 0;
  661. if (IS_ERR(user_addr))
  662. err = PTR_ERR(user_addr);
  663. return err;
  665. }
  667. /*
  668.  * detach and kill segment if marked destroyed.
  669.  * The work is done in shm_close.
  670.  */
  671. asmlinkage long sys_shmdt (char *shmaddr)
  672. {
  673. struct mm_struct *mm = current->mm;
  674. struct vm_area_struct *shmd, *shmdnext;
  676. down_write(&mm->mmap_sem);
  677. for (shmd = mm->mmap; shmd; shmd = shmdnext) {
  678. shmdnext = shmd->vm_next;
  679. if (shmd->vm_ops == &shm_vm_ops
  680.     && shmd->vm_start - (shmd->vm_pgoff << PAGE_SHIFT) == (ulong) shmaddr)
  681. do_munmap(mm, shmd->vm_start, shmd->vm_end - shmd->vm_start);
  682. }
  683. up_write(&mm->mmap_sem);
  684. return 0;
  685. }
  687. #ifdef CONFIG_PROC_FS
  688. static int sysvipc_shm_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data)
  689. {
  690. off_t pos = 0;
  691. off_t begin = 0;
  692. int i, len = 0;
  694. down(&shm_ids.sem);
  695. len += sprintf(buffer, "       key      shmid perms       size  cpid  lpid nattch   uid   gid  cuid  cgid      atime      dtime      ctimen");
  697. for(i = 0; i <= shm_ids.max_id; i++) {
  698. struct shmid_kernel* shp;
  700. shp = shm_lock(i);
  701. if(shp!=NULL) {
  702. #define SMALL_STRING "%10d %10d  %4o %10u %5u %5u  %5d %5u %5u %5u %5u %10lu %10lu %10lun"
  703. #define BIG_STRING   "%10d %10d  %4o %21u %5u %5u  %5d %5u %5u %5u %5u %10lu %10lu %10lun"
  704. char *format;
  706. if (sizeof(size_t) <= sizeof(int))
  707. format = SMALL_STRING;
  708. else
  709. format = BIG_STRING;
  710. len += sprintf(buffer + len, format,
  711. shp->shm_perm.key,
  712. shm_buildid(i, shp->shm_perm.seq),
  713. shp->shm_flags,
  714. shp->shm_segsz,
  715. shp->shm_cprid,
  716. shp->shm_lprid,
  717. shp->shm_nattch,
  718. shp->shm_perm.uid,
  719. shp->shm_perm.gid,
  720. shp->shm_perm.cuid,
  721. shp->shm_perm.cgid,
  722. shp->shm_atim,
  723. shp->shm_dtim,
  724. shp->shm_ctim);
  725. shm_unlock(i);
  727. pos += len;
  728. if(pos < offset) {
  729. len = 0;
  730. begin = pos;
  731. }
  732. if(pos > offset + length)
  733. goto done;
  734. }
  735. }
  736. *eof = 1;
  737. done:
  738. up(&shm_ids.sem);
  739. *start = buffer + (offset - begin);
  740. len -= (offset - begin);
  741. if(len > length)
  742. len = length;
  743. if(len < 0)
  744. len = 0;
  745. return len;
  746. }
  747. #endif