file-nommu.c 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295
  1. /* file-nommu.c: no-MMU version of ramfs
  2. *
  3. * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved.
  4. * Written by David Howells (dhowells@redhat.com)
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public License
  8. * as published by the Free Software Foundation; either version
  9. * 2 of the License, or (at your option) any later version.
  10. */
  11. #include <linux/module.h>
  12. #include <linux/fs.h>
  13. #include <linux/mm.h>
  14. #include <linux/pagemap.h>
  15. #include <linux/highmem.h>
  16. #include <linux/init.h>
  17. #include <linux/string.h>
  18. #include <linux/smp_lock.h>
  19. #include <linux/backing-dev.h>
  20. #include <linux/ramfs.h>
  21. #include <linux/quotaops.h>
  22. #include <linux/pagevec.h>
  23. #include <linux/mman.h>
  24. #include <asm/uaccess.h>
  25. #include "internal.h"
  26. static int ramfs_nommu_setattr(struct dentry *, struct iattr *);
  27. const struct address_space_operations ramfs_aops = {
  28. .readpage = simple_readpage,
  29. .prepare_write = simple_prepare_write,
  30. .commit_write = simple_commit_write,
  31. .set_page_dirty = __set_page_dirty_no_writeback,
  32. };
  33. const struct file_operations ramfs_file_operations = {
  34. .mmap = ramfs_nommu_mmap,
  35. .get_unmapped_area = ramfs_nommu_get_unmapped_area,
  36. .read = do_sync_read,
  37. .aio_read = generic_file_aio_read,
  38. .write = do_sync_write,
  39. .aio_write = generic_file_aio_write,
  40. .fsync = simple_sync_file,
  41. .sendfile = generic_file_sendfile,
  42. .llseek = generic_file_llseek,
  43. };
  44. const struct inode_operations ramfs_file_inode_operations = {
  45. .setattr = ramfs_nommu_setattr,
  46. .getattr = simple_getattr,
  47. };
  48. /*****************************************************************************/
  49. /*
  50. * add a contiguous set of pages into a ramfs inode when it's truncated from
  51. * size 0 on the assumption that it's going to be used for an mmap of shared
  52. * memory
  53. */
  54. static int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
  55. {
  56. struct pagevec lru_pvec;
  57. unsigned long npages, xpages, loop, limit;
  58. struct page *pages;
  59. unsigned order;
  60. void *data;
  61. int ret;
  62. /* make various checks */
  63. order = get_order(newsize);
  64. if (unlikely(order >= MAX_ORDER))
  65. goto too_big;
  66. limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
  67. if (limit != RLIM_INFINITY && newsize > limit)
  68. goto fsize_exceeded;
  69. if (newsize > inode->i_sb->s_maxbytes)
  70. goto too_big;
  71. i_size_write(inode, newsize);
  72. /* allocate enough contiguous pages to be able to satisfy the
  73. * request */
  74. pages = alloc_pages(mapping_gfp_mask(inode->i_mapping), order);
  75. if (!pages)
  76. return -ENOMEM;
  77. /* split the high-order page into an array of single pages */
  78. xpages = 1UL << order;
  79. npages = (newsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
  80. split_page(pages, order);
  81. /* trim off any pages we don't actually require */
  82. for (loop = npages; loop < xpages; loop++)
  83. __free_page(pages + loop);
  84. /* clear the memory we allocated */
  85. newsize = PAGE_SIZE * npages;
  86. data = page_address(pages);
  87. memset(data, 0, newsize);
  88. /* attach all the pages to the inode's address space */
  89. pagevec_init(&lru_pvec, 0);
  90. for (loop = 0; loop < npages; loop++) {
  91. struct page *page = pages + loop;
  92. ret = add_to_page_cache(page, inode->i_mapping, loop, GFP_KERNEL);
  93. if (ret < 0)
  94. goto add_error;
  95. if (!pagevec_add(&lru_pvec, page))
  96. __pagevec_lru_add(&lru_pvec);
  97. unlock_page(page);
  98. }
  99. pagevec_lru_add(&lru_pvec);
  100. return 0;
  101. fsize_exceeded:
  102. send_sig(SIGXFSZ, current, 0);
  103. too_big:
  104. return -EFBIG;
  105. add_error:
  106. page_cache_release(pages + loop);
  107. for (loop++; loop < npages; loop++)
  108. __free_page(pages + loop);
  109. return ret;
  110. }
  111. /*****************************************************************************/
  112. /*
  113. * check that file shrinkage doesn't leave any VMAs dangling in midair
  114. */
  115. static int ramfs_nommu_check_mappings(struct inode *inode,
  116. size_t newsize, size_t size)
  117. {
  118. struct vm_area_struct *vma;
  119. struct prio_tree_iter iter;
  120. /* search for VMAs that fall within the dead zone */
  121. vma_prio_tree_foreach(vma, &iter, &inode->i_mapping->i_mmap,
  122. newsize >> PAGE_SHIFT,
  123. (size + PAGE_SIZE - 1) >> PAGE_SHIFT
  124. ) {
  125. /* found one - only interested if it's shared out of the page
  126. * cache */
  127. if (vma->vm_flags & VM_SHARED)
  128. return -ETXTBSY; /* not quite true, but near enough */
  129. }
  130. return 0;
  131. }
  132. /*****************************************************************************/
  133. /*
  134. *
  135. */
  136. static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size)
  137. {
  138. int ret;
  139. /* assume a truncate from zero size is going to be for the purposes of
  140. * shared mmap */
  141. if (size == 0) {
  142. if (unlikely(newsize >> 32))
  143. return -EFBIG;
  144. return ramfs_nommu_expand_for_mapping(inode, newsize);
  145. }
  146. /* check that a decrease in size doesn't cut off any shared mappings */
  147. if (newsize < size) {
  148. ret = ramfs_nommu_check_mappings(inode, newsize, size);
  149. if (ret < 0)
  150. return ret;
  151. }
  152. ret = vmtruncate(inode, size);
  153. return ret;
  154. }
  155. /*****************************************************************************/
  156. /*
  157. * handle a change of attributes
  158. * - we're specifically interested in a change of size
  159. */
  160. static int ramfs_nommu_setattr(struct dentry *dentry, struct iattr *ia)
  161. {
  162. struct inode *inode = dentry->d_inode;
  163. unsigned int old_ia_valid = ia->ia_valid;
  164. int ret = 0;
  165. /* by providing our own setattr() method, we skip this quotaism */
  166. if ((old_ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
  167. (old_ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid))
  168. ret = DQUOT_TRANSFER(inode, ia) ? -EDQUOT : 0;
  169. /* pick out size-changing events */
  170. if (ia->ia_valid & ATTR_SIZE) {
  171. loff_t size = i_size_read(inode);
  172. if (ia->ia_size != size) {
  173. ret = ramfs_nommu_resize(inode, ia->ia_size, size);
  174. if (ret < 0 || ia->ia_valid == ATTR_SIZE)
  175. goto out;
  176. } else {
  177. /* we skipped the truncate but must still update
  178. * timestamps
  179. */
  180. ia->ia_valid |= ATTR_MTIME|ATTR_CTIME;
  181. }
  182. }
  183. ret = inode_setattr(inode, ia);
  184. out:
  185. ia->ia_valid = old_ia_valid;
  186. return ret;
  187. }
  188. /*****************************************************************************/
  189. /*
  190. * try to determine where a shared mapping can be made
  191. * - we require that:
  192. * - the pages to be mapped must exist
  193. * - the pages be physically contiguous in sequence
  194. */
  195. unsigned long ramfs_nommu_get_unmapped_area(struct file *file,
  196. unsigned long addr, unsigned long len,
  197. unsigned long pgoff, unsigned long flags)
  198. {
  199. unsigned long maxpages, lpages, nr, loop, ret;
  200. struct inode *inode = file->f_path.dentry->d_inode;
  201. struct page **pages = NULL, **ptr, *page;
  202. loff_t isize;
  203. if (!(flags & MAP_SHARED))
  204. return addr;
  205. /* the mapping mustn't extend beyond the EOF */
  206. lpages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
  207. isize = i_size_read(inode);
  208. ret = -EINVAL;
  209. maxpages = (isize + PAGE_SIZE - 1) >> PAGE_SHIFT;
  210. if (pgoff >= maxpages)
  211. goto out;
  212. if (maxpages - pgoff < lpages)
  213. goto out;
  214. /* gang-find the pages */
  215. ret = -ENOMEM;
  216. pages = kzalloc(lpages * sizeof(struct page *), GFP_KERNEL);
  217. if (!pages)
  218. goto out;
  219. nr = find_get_pages(inode->i_mapping, pgoff, lpages, pages);
  220. if (nr != lpages)
  221. goto out; /* leave if some pages were missing */
  222. /* check the pages for physical adjacency */
  223. ptr = pages;
  224. page = *ptr++;
  225. page++;
  226. for (loop = lpages; loop > 1; loop--)
  227. if (*ptr++ != page++)
  228. goto out;
  229. /* okay - all conditions fulfilled */
  230. ret = (unsigned long) page_address(pages[0]);
  231. out:
  232. if (pages) {
  233. ptr = pages;
  234. for (loop = lpages; loop > 0; loop--)
  235. put_page(*ptr++);
  236. kfree(pages);
  237. }
  238. return ret;
  239. }
  240. /*****************************************************************************/
  241. /*
  242. * set up a mapping for shared memory segments
  243. */
  244. int ramfs_nommu_mmap(struct file *file, struct vm_area_struct *vma)
  245. {
  246. return vma->vm_flags & VM_SHARED ? 0 : -ENOSYS;
  247. }