5 * File handling routines for the OSTA-UDF(tm) filesystem.
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.
13 * (C) 1998-1999 Dave Boynton
14 * (C) 1998-2004 Ben Fennema
15 * (C) 1999-2000 Stelias Computing Inc
19 * 10/02/98 dgb Attempt to integrate into udf.o
20 * 10/07/98 Switched to using generic_readpage, etc., like isofs
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
30 #include <linux/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/pagemap.h>
36 #include <linux/uio.h>
41 static void __udf_adinicb_readpage(struct page
*page
)
43 struct inode
*inode
= page
->mapping
->host
;
45 struct udf_inode_info
*iinfo
= UDF_I(inode
);
46 loff_t isize
= i_size_read(inode
);
49 * We have to be careful here as truncate can change i_size under us.
50 * So just sample it once and use the same value everywhere.
52 kaddr
= kmap_atomic(page
);
53 memcpy(kaddr
, iinfo
->i_data
+ iinfo
->i_lenEAttr
, isize
);
54 memset(kaddr
+ isize
, 0, PAGE_SIZE
- isize
);
55 flush_dcache_page(page
);
56 SetPageUptodate(page
);
60 static int udf_adinicb_readpage(struct file
*file
, struct page
*page
)
62 BUG_ON(!PageLocked(page
));
63 __udf_adinicb_readpage(page
);
69 static int udf_adinicb_writepage(struct page
*page
,
70 struct writeback_control
*wbc
)
72 struct inode
*inode
= page
->mapping
->host
;
74 struct udf_inode_info
*iinfo
= UDF_I(inode
);
76 BUG_ON(!PageLocked(page
));
78 kaddr
= kmap_atomic(page
);
79 memcpy(iinfo
->i_data
+ iinfo
->i_lenEAttr
, kaddr
, i_size_read(inode
));
80 SetPageUptodate(page
);
82 mark_inode_dirty(inode
);
88 static int udf_adinicb_write_begin(struct file
*file
,
89 struct address_space
*mapping
, loff_t pos
,
90 unsigned len
, unsigned flags
, struct page
**pagep
,
95 if (WARN_ON_ONCE(pos
>= PAGE_SIZE
))
97 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
102 if (!PageUptodate(page
))
103 __udf_adinicb_readpage(page
);
107 static ssize_t
udf_adinicb_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
109 /* Fallback to buffered I/O. */
113 static int udf_adinicb_write_end(struct file
*file
, struct address_space
*mapping
,
114 loff_t pos
, unsigned len
, unsigned copied
,
115 struct page
*page
, void *fsdata
)
117 struct inode
*inode
= page
->mapping
->host
;
118 loff_t last_pos
= pos
+ copied
;
119 if (last_pos
> inode
->i_size
)
120 i_size_write(inode
, last_pos
);
121 set_page_dirty(page
);
127 const struct address_space_operations udf_adinicb_aops
= {
128 .readpage
= udf_adinicb_readpage
,
129 .writepage
= udf_adinicb_writepage
,
130 .write_begin
= udf_adinicb_write_begin
,
131 .write_end
= udf_adinicb_write_end
,
132 .direct_IO
= udf_adinicb_direct_IO
,
135 static ssize_t
udf_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
138 struct file
*file
= iocb
->ki_filp
;
139 struct inode
*inode
= file_inode(file
);
140 struct udf_inode_info
*iinfo
= UDF_I(inode
);
145 retval
= generic_write_checks(iocb
, from
);
149 down_write(&iinfo
->i_data_sem
);
150 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
151 loff_t end
= iocb
->ki_pos
+ iov_iter_count(from
);
153 if (inode
->i_sb
->s_blocksize
<
154 (udf_file_entry_alloc_offset(inode
) + end
)) {
155 err
= udf_expand_file_adinicb(inode
);
158 udf_debug("udf_expand_adinicb: err=%d\n", err
);
162 iinfo
->i_lenAlloc
= max(end
, inode
->i_size
);
163 up_write(&iinfo
->i_data_sem
);
166 up_write(&iinfo
->i_data_sem
);
168 retval
= __generic_file_write_iter(iocb
, from
);
173 mark_inode_dirty(inode
);
174 retval
= generic_write_sync(iocb
, retval
);
180 long udf_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
182 struct inode
*inode
= file_inode(filp
);
183 long old_block
, new_block
;
186 if (inode_permission(inode
, MAY_READ
) != 0) {
187 udf_debug("no permission to access inode %lu\n", inode
->i_ino
);
191 if (!arg
&& ((cmd
== UDF_GETVOLIDENT
) || (cmd
== UDF_GETEASIZE
) ||
192 (cmd
== UDF_RELOCATE_BLOCKS
) || (cmd
== UDF_GETEABLOCK
))) {
193 udf_debug("invalid argument to udf_ioctl\n");
198 case UDF_GETVOLIDENT
:
199 if (copy_to_user((char __user
*)arg
,
200 UDF_SB(inode
->i_sb
)->s_volume_ident
, 32))
203 case UDF_RELOCATE_BLOCKS
:
204 if (!capable(CAP_SYS_ADMIN
))
206 if (get_user(old_block
, (long __user
*)arg
))
208 result
= udf_relocate_blocks(inode
->i_sb
,
209 old_block
, &new_block
);
211 result
= put_user(new_block
, (long __user
*)arg
);
214 return put_user(UDF_I(inode
)->i_lenEAttr
, (int __user
*)arg
);
216 return copy_to_user((char __user
*)arg
,
217 UDF_I(inode
)->i_data
,
218 UDF_I(inode
)->i_lenEAttr
) ? -EFAULT
: 0;
226 static int udf_release_file(struct inode
*inode
, struct file
*filp
)
228 if (filp
->f_mode
& FMODE_WRITE
&&
229 atomic_read(&inode
->i_writecount
) == 1) {
231 * Grab i_mutex to avoid races with writes changing i_size
232 * while we are running.
235 down_write(&UDF_I(inode
)->i_data_sem
);
236 udf_discard_prealloc(inode
);
237 udf_truncate_tail_extent(inode
);
238 up_write(&UDF_I(inode
)->i_data_sem
);
244 const struct file_operations udf_file_operations
= {
245 .read_iter
= generic_file_read_iter
,
246 .unlocked_ioctl
= udf_ioctl
,
247 .open
= generic_file_open
,
248 .mmap
= generic_file_mmap
,
249 .write_iter
= udf_file_write_iter
,
250 .release
= udf_release_file
,
251 .fsync
= generic_file_fsync
,
252 .splice_read
= generic_file_splice_read
,
253 .llseek
= generic_file_llseek
,
256 static int udf_setattr(struct dentry
*dentry
, struct iattr
*attr
)
258 struct inode
*inode
= d_inode(dentry
);
259 struct super_block
*sb
= inode
->i_sb
;
262 error
= setattr_prepare(dentry
, attr
);
266 if ((attr
->ia_valid
& ATTR_UID
) &&
267 UDF_QUERY_FLAG(sb
, UDF_FLAG_UID_SET
) &&
268 !uid_eq(attr
->ia_uid
, UDF_SB(sb
)->s_uid
))
270 if ((attr
->ia_valid
& ATTR_GID
) &&
271 UDF_QUERY_FLAG(sb
, UDF_FLAG_GID_SET
) &&
272 !gid_eq(attr
->ia_gid
, UDF_SB(sb
)->s_gid
))
275 if ((attr
->ia_valid
& ATTR_SIZE
) &&
276 attr
->ia_size
!= i_size_read(inode
)) {
277 error
= udf_setsize(inode
, attr
->ia_size
);
282 if (attr
->ia_valid
& ATTR_MODE
)
283 udf_update_extra_perms(inode
, attr
->ia_mode
);
285 setattr_copy(inode
, attr
);
286 mark_inode_dirty(inode
);
290 const struct inode_operations udf_file_inode_operations
= {
291 .setattr
= udf_setattr
,