xref: /openbmc/linux/fs/udf/file.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
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 
40 #include "udf_i.h"
41 #include "udf_sb.h"
42 
43 static int udf_adinicb_readpage(struct file *file, struct page * page)
44 {
45 	struct inode *inode = page->mapping->host;
46 	char *kaddr;
47 
48 	BUG_ON(!PageLocked(page));
49 
50 	kaddr = kmap(page);
51 	memset(kaddr, 0, PAGE_CACHE_SIZE);
52 	memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), inode->i_size);
53 	flush_dcache_page(page);
54 	SetPageUptodate(page);
55 	kunmap(page);
56 	unlock_page(page);
57 	return 0;
58 }
59 
60 static int udf_adinicb_writepage(struct page *page, struct writeback_control *wbc)
61 {
62 	struct inode *inode = page->mapping->host;
63 	char *kaddr;
64 
65 	BUG_ON(!PageLocked(page));
66 
67 	kaddr = kmap(page);
68 	memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), kaddr, inode->i_size);
69 	mark_inode_dirty(inode);
70 	SetPageUptodate(page);
71 	kunmap(page);
72 	unlock_page(page);
73 	return 0;
74 }
75 
76 static int udf_adinicb_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to)
77 {
78 	kmap(page);
79 	return 0;
80 }
81 
82 static int udf_adinicb_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to)
83 {
84 	struct inode *inode = page->mapping->host;
85 	char *kaddr = page_address(page);
86 
87 	memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset,
88 		kaddr + offset, to - offset);
89 	mark_inode_dirty(inode);
90 	SetPageUptodate(page);
91 	kunmap(page);
92 	/* only one page here */
93 	if (to > inode->i_size)
94 		inode->i_size = to;
95 	return 0;
96 }
97 
98 const struct address_space_operations udf_adinicb_aops = {
99 	.readpage		= udf_adinicb_readpage,
100 	.writepage		= udf_adinicb_writepage,
101 	.sync_page		= block_sync_page,
102 	.prepare_write		= udf_adinicb_prepare_write,
103 	.commit_write		= udf_adinicb_commit_write,
104 };
105 
106 static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
107 			      unsigned long nr_segs, loff_t ppos)
108 {
109 	ssize_t retval;
110 	struct file *file = iocb->ki_filp;
111 	struct inode *inode = file->f_path.dentry->d_inode;
112 	int err, pos;
113 	size_t count = iocb->ki_left;
114 
115 	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
116 	{
117 		if (file->f_flags & O_APPEND)
118 			pos = inode->i_size;
119 		else
120 			pos = ppos;
121 
122 		if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
123 			pos + count))
124 		{
125 			udf_expand_file_adinicb(inode, pos + count, &err);
126 			if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
127 			{
128 				udf_debug("udf_expand_adinicb: err=%d\n", err);
129 				return err;
130 			}
131 		}
132 		else
133 		{
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 
143 	if (retval > 0)
144 		mark_inode_dirty(inode);
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 	int result = -EINVAL;
186 
187 	if ( file_permission(filp, MAY_READ) != 0 )
188 	{
189 		udf_debug("no permission to access inode %lu\n",
190 						inode->i_ino);
191 		return -EPERM;
192 	}
193 
194 	if ( !arg )
195 	{
196 		udf_debug("invalid argument to udf_ioctl\n");
197 		return -EINVAL;
198 	}
199 
200 	switch (cmd)
201 	{
202 		case UDF_GETVOLIDENT:
203 			return copy_to_user((char __user *)arg,
204 				UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
205 		case UDF_RELOCATE_BLOCKS:
206 		{
207 			long old, new;
208 
209 			if (!capable(CAP_SYS_ADMIN)) return -EACCES;
210 			if (get_user(old, (long __user *)arg)) return -EFAULT;
211 			if ((result = udf_relocate_blocks(inode->i_sb,
212 					old, &new)) == 0)
213 				result = put_user(new, (long __user *)arg);
214 
215 			return result;
216 		}
217 		case UDF_GETEASIZE:
218 			result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);
219 			break;
220 
221 		case UDF_GETEABLOCK:
222 			result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),
223 				UDF_I_LENEATTR(inode)) ? -EFAULT : 0;
224 			break;
225 	}
226 
227 	return result;
228 }
229 
230 /*
231  * udf_release_file
232  *
233  * PURPOSE
234  *  Called when all references to the file are closed
235  *
236  * DESCRIPTION
237  *  Discard prealloced blocks
238  *
239  * HISTORY
240  *
241  */
242 static int udf_release_file(struct inode * inode, struct file * filp)
243 {
244 	if (filp->f_mode & FMODE_WRITE)
245 	{
246 		lock_kernel();
247 		udf_discard_prealloc(inode);
248 		unlock_kernel();
249 	}
250 	return 0;
251 }
252 
253 const struct file_operations udf_file_operations = {
254 	.read			= do_sync_read,
255 	.aio_read		= generic_file_aio_read,
256 	.ioctl			= udf_ioctl,
257 	.open			= generic_file_open,
258 	.mmap			= generic_file_mmap,
259 	.write			= do_sync_write,
260 	.aio_write		= udf_file_aio_write,
261 	.release		= udf_release_file,
262 	.fsync			= udf_fsync_file,
263 	.sendfile		= generic_file_sendfile,
264 };
265 
266 const struct inode_operations udf_file_inode_operations = {
267 	.truncate		= udf_truncate,
268 };
269