Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[pandora-kernel.git] / fs / udf / file.c
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
28 #include "udfdecl.h"
29 #include <linux/fs.h>
30 #include <linux/udf_fs.h>
31 #include <asm/uaccess.h>
32 #include <linux/kernel.h>
33 #include <linux/string.h> /* memset */
34 #include <linux/capability.h>
35 #include <linux/errno.h>
36 #include <linux/smp_lock.h>
37 #include <linux/pagemap.h>
38 #include <linux/buffer_head.h>
39 #include <linux/aio.h>
40
41 #include "udf_i.h"
42 #include "udf_sb.h"
43
44 static int udf_adinicb_readpage(struct file *file, struct page *page)
45 {
46         struct inode *inode = page->mapping->host;
47         char *kaddr;
48
49         BUG_ON(!PageLocked(page));
50
51         kaddr = kmap(page);
52         memset(kaddr, 0, PAGE_CACHE_SIZE);
53         memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), inode->i_size);
54         flush_dcache_page(page);
55         SetPageUptodate(page);
56         kunmap(page);
57         unlock_page(page);
58
59         return 0;
60 }
61
62 static int udf_adinicb_writepage(struct page *page, struct writeback_control *wbc)
63 {
64         struct inode *inode = page->mapping->host;
65         char *kaddr;
66
67         BUG_ON(!PageLocked(page));
68
69         kaddr = kmap(page);
70         memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), kaddr, inode->i_size);
71         mark_inode_dirty(inode);
72         SetPageUptodate(page);
73         kunmap(page);
74         unlock_page(page);
75
76         return 0;
77 }
78
79 static int udf_adinicb_prepare_write(struct file *file, struct page *page,
80                                      unsigned offset, unsigned to)
81 {
82         kmap(page);
83         return 0;
84 }
85
86 static int udf_adinicb_commit_write(struct file *file, struct page *page,
87                                     unsigned offset, unsigned to)
88 {
89         struct inode *inode = page->mapping->host;
90         char *kaddr = page_address(page);
91
92         memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset,
93                kaddr + offset, to - offset);
94         mark_inode_dirty(inode);
95         SetPageUptodate(page);
96         kunmap(page);
97         /* only one page here */
98         if (to > inode->i_size)
99                 inode->i_size = to;
100         return 0;
101 }
102
103 const struct address_space_operations udf_adinicb_aops = {
104         .readpage       = udf_adinicb_readpage,
105         .writepage      = udf_adinicb_writepage,
106         .sync_page      = block_sync_page,
107         .prepare_write  = udf_adinicb_prepare_write,
108         .commit_write   = udf_adinicb_commit_write,
109 };
110
111 static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
112                                   unsigned long nr_segs, loff_t ppos)
113 {
114         ssize_t retval;
115         struct file *file = iocb->ki_filp;
116         struct inode *inode = file->f_path.dentry->d_inode;
117         int err, pos;
118         size_t count = iocb->ki_left;
119
120         if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
121                 if (file->f_flags & O_APPEND)
122                         pos = inode->i_size;
123                 else
124                         pos = ppos;
125
126                 if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
127                                                 pos + count)) {
128                         udf_expand_file_adinicb(inode, pos + count, &err);
129                         if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
130                                 udf_debug("udf_expand_adinicb: err=%d\n", err);
131                                 return err;
132                         }
133                 } else {
134                         if (pos + count > inode->i_size)
135                                 UDF_I_LENALLOC(inode) = pos + count;
136                         else
137                                 UDF_I_LENALLOC(inode) = inode->i_size;
138                 }
139         }
140
141         retval = generic_file_aio_write(iocb, iov, nr_segs, ppos);
142         if (retval > 0)
143                 mark_inode_dirty(inode);
144
145         return retval;
146 }
147
148 /*
149  * udf_ioctl
150  *
151  * PURPOSE
152  *      Issue an ioctl.
153  *
154  * DESCRIPTION
155  *      Optional - sys_ioctl() will return -ENOTTY if this routine is not
156  *      available, and the ioctl cannot be handled without filesystem help.
157  *
158  *      sys_ioctl() handles these ioctls that apply only to regular files:
159  *              FIBMAP [requires udf_block_map()], FIGETBSZ, FIONREAD
160  *      These ioctls are also handled by sys_ioctl():
161  *              FIOCLEX, FIONCLEX, FIONBIO, FIOASYNC
162  *      All other ioctls are passed to the filesystem.
163  *
164  *      Refer to sys_ioctl() in fs/ioctl.c
165  *      sys_ioctl() -> .
166  *
167  * PRE-CONDITIONS
168  *      inode                   Pointer to inode that ioctl was issued on.
169  *      filp                    Pointer to file that ioctl was issued on.
170  *      cmd                     The ioctl command.
171  *      arg                     The ioctl argument [can be interpreted as a
172  *                              user-space pointer if desired].
173  *
174  * POST-CONDITIONS
175  *      <return>                Success (>=0) or an error code (<=0) that
176  *                              sys_ioctl() will return.
177  *
178  * HISTORY
179  *      July 1, 1997 - Andrew E. Mileski
180  *      Written, tested, and released.
181  */
182 int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
183               unsigned long arg)
184 {
185         long old_block, new_block;
186         int result = -EINVAL;
187
188         if (file_permission(filp, MAY_READ) != 0) {
189                 udf_debug("no permission to access inode %lu\n",
190                           inode->i_ino);
191                 return -EPERM;
192         }
193
194         if (!arg) {
195                 udf_debug("invalid argument to udf_ioctl\n");
196                 return -EINVAL;
197         }
198
199         switch (cmd) {
200         case UDF_GETVOLIDENT:
201                 return copy_to_user((char __user *)arg,
202                                     UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
203         case UDF_RELOCATE_BLOCKS:
204                 if (!capable(CAP_SYS_ADMIN))
205                         return -EACCES;
206                 if (get_user(old_block, (long __user *)arg))
207                         return -EFAULT;
208                 if ((result = udf_relocate_blocks(inode->i_sb,
209                                                   old_block, &new_block)) == 0)
210                         result = put_user(new_block, (long __user *)arg);
211                 return result;
212         case UDF_GETEASIZE:
213                 result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);
214                 break;
215         case UDF_GETEABLOCK:
216                 result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),
217                                       UDF_I_LENEATTR(inode)) ? -EFAULT : 0;
218                 break;
219         }
220
221         return result;
222 }
223
224 /*
225  * udf_release_file
226  *
227  * PURPOSE
228  *  Called when all references to the file are closed
229  *
230  * DESCRIPTION
231  *  Discard prealloced blocks
232  *
233  * HISTORY
234  *
235  */
236 static int udf_release_file(struct inode *inode, struct file *filp)
237 {
238         if (filp->f_mode & FMODE_WRITE) {
239                 lock_kernel();
240                 udf_discard_prealloc(inode);
241                 unlock_kernel();
242         }
243         return 0;
244 }
245
246 const struct file_operations udf_file_operations = {
247         .read                   = do_sync_read,
248         .aio_read               = generic_file_aio_read,
249         .ioctl                  = udf_ioctl,
250         .open                   = generic_file_open,
251         .mmap                   = generic_file_mmap,
252         .write                  = do_sync_write,
253         .aio_write              = udf_file_aio_write,
254         .release                = udf_release_file,
255         .fsync                  = udf_fsync_file,
256         .splice_read            = generic_file_splice_read,
257 };
258
259 const struct inode_operations udf_file_inode_operations = {
260         .truncate = udf_truncate,
261 };