file.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268
  1. /*
  2. * file.c
  3. *
  4. * PURPOSE
  5. * File handling routines for the OSTA-UDF(tm) filesystem.
  6. *
  7. * COPYRIGHT
  8. * This file is distributed under the terms of the GNU General Public
  9. * License (GPL). Copies of the GPL can be obtained from:
  10. * ftp://prep.ai.mit.edu/pub/gnu/GPL
  11. * Each contributing author retains all rights to their own work.
  12. *
  13. * (C) 1998-1999 Dave Boynton
  14. * (C) 1998-2004 Ben Fennema
  15. * (C) 1999-2000 Stelias Computing Inc
  16. *
  17. * HISTORY
  18. *
  19. * 10/02/98 dgb Attempt to integrate into udf.o
  20. * 10/07/98 Switched to using generic_readpage, etc., like isofs
  21. * And it works!
  22. * 12/06/98 blf Added udf_file_read. uses generic_file_read for all cases but
  23. * ICBTAG_FLAG_AD_IN_ICB.
  24. * 04/06/99 64 bit file handling on 32 bit systems taken from ext2 file.c
  25. * 05/12/99 Preliminary file write support
  26. */
  27. #include "udfdecl.h"
  28. #include <linux/fs.h>
  29. #include <linux/udf_fs.h>
  30. #include <asm/uaccess.h>
  31. #include <linux/kernel.h>
  32. #include <linux/string.h> /* memset */
  33. #include <linux/capability.h>
  34. #include <linux/errno.h>
  35. #include <linux/smp_lock.h>
  36. #include <linux/pagemap.h>
  37. #include <linux/buffer_head.h>
  38. #include "udf_i.h"
  39. #include "udf_sb.h"
  40. static int udf_adinicb_readpage(struct file *file, struct page * page)
  41. {
  42. struct inode *inode = page->mapping->host;
  43. char *kaddr;
  44. BUG_ON(!PageLocked(page));
  45. kaddr = kmap(page);
  46. memset(kaddr, 0, PAGE_CACHE_SIZE);
  47. memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), inode->i_size);
  48. flush_dcache_page(page);
  49. SetPageUptodate(page);
  50. kunmap(page);
  51. unlock_page(page);
  52. return 0;
  53. }
  54. static int udf_adinicb_writepage(struct page *page, struct writeback_control *wbc)
  55. {
  56. struct inode *inode = page->mapping->host;
  57. char *kaddr;
  58. BUG_ON(!PageLocked(page));
  59. kaddr = kmap(page);
  60. memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), kaddr, inode->i_size);
  61. mark_inode_dirty(inode);
  62. SetPageUptodate(page);
  63. kunmap(page);
  64. unlock_page(page);
  65. return 0;
  66. }
  67. static int udf_adinicb_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to)
  68. {
  69. kmap(page);
  70. return 0;
  71. }
  72. static int udf_adinicb_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to)
  73. {
  74. struct inode *inode = page->mapping->host;
  75. char *kaddr = page_address(page);
  76. memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset,
  77. kaddr + offset, to - offset);
  78. mark_inode_dirty(inode);
  79. SetPageUptodate(page);
  80. kunmap(page);
  81. /* only one page here */
  82. if (to > inode->i_size)
  83. inode->i_size = to;
  84. return 0;
  85. }
  86. const struct address_space_operations udf_adinicb_aops = {
  87. .readpage = udf_adinicb_readpage,
  88. .writepage = udf_adinicb_writepage,
  89. .sync_page = block_sync_page,
  90. .prepare_write = udf_adinicb_prepare_write,
  91. .commit_write = udf_adinicb_commit_write,
  92. };
  93. static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
  94. unsigned long nr_segs, loff_t ppos)
  95. {
  96. ssize_t retval;
  97. struct file *file = iocb->ki_filp;
  98. struct inode *inode = file->f_path.dentry->d_inode;
  99. int err, pos;
  100. size_t count = iocb->ki_left;
  101. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
  102. {
  103. if (file->f_flags & O_APPEND)
  104. pos = inode->i_size;
  105. else
  106. pos = ppos;
  107. if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
  108. pos + count))
  109. {
  110. udf_expand_file_adinicb(inode, pos + count, &err);
  111. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
  112. {
  113. udf_debug("udf_expand_adinicb: err=%d\n", err);
  114. return err;
  115. }
  116. }
  117. else
  118. {
  119. if (pos + count > inode->i_size)
  120. UDF_I_LENALLOC(inode) = pos + count;
  121. else
  122. UDF_I_LENALLOC(inode) = inode->i_size;
  123. }
  124. }
  125. retval = generic_file_aio_write(iocb, iov, nr_segs, ppos);
  126. if (retval > 0)
  127. mark_inode_dirty(inode);
  128. return retval;
  129. }
  130. /*
  131. * udf_ioctl
  132. *
  133. * PURPOSE
  134. * Issue an ioctl.
  135. *
  136. * DESCRIPTION
  137. * Optional - sys_ioctl() will return -ENOTTY if this routine is not
  138. * available, and the ioctl cannot be handled without filesystem help.
  139. *
  140. * sys_ioctl() handles these ioctls that apply only to regular files:
  141. * FIBMAP [requires udf_block_map()], FIGETBSZ, FIONREAD
  142. * These ioctls are also handled by sys_ioctl():
  143. * FIOCLEX, FIONCLEX, FIONBIO, FIOASYNC
  144. * All other ioctls are passed to the filesystem.
  145. *
  146. * Refer to sys_ioctl() in fs/ioctl.c
  147. * sys_ioctl() -> .
  148. *
  149. * PRE-CONDITIONS
  150. * inode Pointer to inode that ioctl was issued on.
  151. * filp Pointer to file that ioctl was issued on.
  152. * cmd The ioctl command.
  153. * arg The ioctl argument [can be interpreted as a
  154. * user-space pointer if desired].
  155. *
  156. * POST-CONDITIONS
  157. * <return> Success (>=0) or an error code (<=0) that
  158. * sys_ioctl() will return.
  159. *
  160. * HISTORY
  161. * July 1, 1997 - Andrew E. Mileski
  162. * Written, tested, and released.
  163. */
  164. int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
  165. unsigned long arg)
  166. {
  167. int result = -EINVAL;
  168. if ( file_permission(filp, MAY_READ) != 0 )
  169. {
  170. udf_debug("no permission to access inode %lu\n",
  171. inode->i_ino);
  172. return -EPERM;
  173. }
  174. if ( !arg )
  175. {
  176. udf_debug("invalid argument to udf_ioctl\n");
  177. return -EINVAL;
  178. }
  179. switch (cmd)
  180. {
  181. case UDF_GETVOLIDENT:
  182. return copy_to_user((char __user *)arg,
  183. UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
  184. case UDF_RELOCATE_BLOCKS:
  185. {
  186. long old, new;
  187. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  188. if (get_user(old, (long __user *)arg)) return -EFAULT;
  189. if ((result = udf_relocate_blocks(inode->i_sb,
  190. old, &new)) == 0)
  191. result = put_user(new, (long __user *)arg);
  192. return result;
  193. }
  194. case UDF_GETEASIZE:
  195. result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);
  196. break;
  197. case UDF_GETEABLOCK:
  198. result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),
  199. UDF_I_LENEATTR(inode)) ? -EFAULT : 0;
  200. break;
  201. }
  202. return result;
  203. }
  204. /*
  205. * udf_release_file
  206. *
  207. * PURPOSE
  208. * Called when all references to the file are closed
  209. *
  210. * DESCRIPTION
  211. * Discard prealloced blocks
  212. *
  213. * HISTORY
  214. *
  215. */
  216. static int udf_release_file(struct inode * inode, struct file * filp)
  217. {
  218. if (filp->f_mode & FMODE_WRITE)
  219. {
  220. lock_kernel();
  221. udf_discard_prealloc(inode);
  222. unlock_kernel();
  223. }
  224. return 0;
  225. }
  226. const struct file_operations udf_file_operations = {
  227. .read = do_sync_read,
  228. .aio_read = generic_file_aio_read,
  229. .ioctl = udf_ioctl,
  230. .open = generic_file_open,
  231. .mmap = generic_file_mmap,
  232. .write = do_sync_write,
  233. .aio_write = udf_file_aio_write,
  234. .release = udf_release_file,
  235. .fsync = udf_fsync_file,
  236. .sendfile = generic_file_sendfile,
  237. };
  238. const struct inode_operations udf_file_inode_operations = {
  239. .truncate = udf_truncate,
  240. };