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/udf_fs.h>
31 #include <asm/uaccess.h>
32 #include <linux/kernel.h>
33 #include <linux/string.h> /* memset */
34 #include <linux/errno.h>
35 #include <linux/smp_lock.h>
36 #include <linux/pagemap.h>
37 #include <linux/buffer_head.h>
42 static int udf_adinicb_readpage(struct file
*file
, struct page
* page
)
44 struct inode
*inode
= page
->mapping
->host
;
47 BUG_ON(!PageLocked(page
));
50 memset(kaddr
, 0, PAGE_CACHE_SIZE
);
51 memcpy(kaddr
, UDF_I_DATA(inode
) + UDF_I_LENEATTR(inode
), inode
->i_size
);
52 flush_dcache_page(page
);
53 SetPageUptodate(page
);
59 static int udf_adinicb_writepage(struct page
*page
, struct writeback_control
*wbc
)
61 struct inode
*inode
= page
->mapping
->host
;
64 BUG_ON(!PageLocked(page
));
67 memcpy(UDF_I_DATA(inode
) + UDF_I_LENEATTR(inode
), kaddr
, inode
->i_size
);
68 mark_inode_dirty(inode
);
69 SetPageUptodate(page
);
75 static int udf_adinicb_prepare_write(struct file
*file
, struct page
*page
, unsigned offset
, unsigned to
)
81 static int udf_adinicb_commit_write(struct file
*file
, struct page
*page
, unsigned offset
, unsigned to
)
83 struct inode
*inode
= page
->mapping
->host
;
84 char *kaddr
= page_address(page
);
86 memcpy(UDF_I_DATA(inode
) + UDF_I_LENEATTR(inode
) + offset
,
87 kaddr
+ offset
, to
- offset
);
88 mark_inode_dirty(inode
);
89 SetPageUptodate(page
);
91 /* only one page here */
92 if (to
> inode
->i_size
)
97 struct address_space_operations udf_adinicb_aops
= {
98 .readpage
= udf_adinicb_readpage
,
99 .writepage
= udf_adinicb_writepage
,
100 .sync_page
= block_sync_page
,
101 .prepare_write
= udf_adinicb_prepare_write
,
102 .commit_write
= udf_adinicb_commit_write
,
105 static ssize_t
udf_file_write(struct file
* file
, const char __user
* buf
,
106 size_t count
, loff_t
*ppos
)
109 struct inode
*inode
= file
->f_dentry
->d_inode
;
112 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_IN_ICB
)
114 if (file
->f_flags
& O_APPEND
)
119 if (inode
->i_sb
->s_blocksize
< (udf_file_entry_alloc_offset(inode
) +
122 udf_expand_file_adinicb(inode
, pos
+ count
, &err
);
123 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_IN_ICB
)
125 udf_debug("udf_expand_adinicb: err=%d\n", err
);
131 if (pos
+ count
> inode
->i_size
)
132 UDF_I_LENALLOC(inode
) = pos
+ count
;
134 UDF_I_LENALLOC(inode
) = inode
->i_size
;
138 retval
= generic_file_write(file
, buf
, count
, ppos
);
141 mark_inode_dirty(inode
);
152 * Optional - sys_ioctl() will return -ENOTTY if this routine is not
153 * available, and the ioctl cannot be handled without filesystem help.
155 * sys_ioctl() handles these ioctls that apply only to regular files:
156 * FIBMAP [requires udf_block_map()], FIGETBSZ, FIONREAD
157 * These ioctls are also handled by sys_ioctl():
158 * FIOCLEX, FIONCLEX, FIONBIO, FIOASYNC
159 * All other ioctls are passed to the filesystem.
161 * Refer to sys_ioctl() in fs/ioctl.c
165 * inode Pointer to inode that ioctl was issued on.
166 * filp Pointer to file that ioctl was issued on.
167 * cmd The ioctl command.
168 * arg The ioctl argument [can be interpreted as a
169 * user-space pointer if desired].
172 * <return> Success (>=0) or an error code (<=0) that
173 * sys_ioctl() will return.
176 * July 1, 1997 - Andrew E. Mileski
177 * Written, tested, and released.
179 int udf_ioctl(struct inode
*inode
, struct file
*filp
, unsigned int cmd
,
182 int result
= -EINVAL
;
184 if ( file_permission(filp
, MAY_READ
) != 0 )
186 udf_debug("no permission to access inode %lu\n",
193 udf_debug("invalid argument to udf_ioctl\n");
199 case UDF_GETVOLIDENT
:
200 return copy_to_user((char __user
*)arg
,
201 UDF_SB_VOLIDENT(inode
->i_sb
), 32) ? -EFAULT
: 0;
202 case UDF_RELOCATE_BLOCKS
:
206 if (!capable(CAP_SYS_ADMIN
)) return -EACCES
;
207 if (get_user(old
, (long __user
*)arg
)) return -EFAULT
;
208 if ((result
= udf_relocate_blocks(inode
->i_sb
,
210 result
= put_user(new, (long __user
*)arg
);
215 result
= put_user(UDF_I_LENEATTR(inode
), (int __user
*)arg
);
219 result
= copy_to_user((char __user
*)arg
, UDF_I_DATA(inode
),
220 UDF_I_LENEATTR(inode
)) ? -EFAULT
: 0;
231 * Called when all references to the file are closed
234 * Discard prealloced blocks
239 static int udf_release_file(struct inode
* inode
, struct file
* filp
)
241 if (filp
->f_mode
& FMODE_WRITE
)
244 udf_discard_prealloc(inode
);
250 struct file_operations udf_file_operations
= {
251 .read
= generic_file_read
,
253 .open
= generic_file_open
,
254 .mmap
= generic_file_mmap
,
255 .write
= udf_file_write
,
256 .release
= udf_release_file
,
257 .fsync
= udf_fsync_file
,
258 .sendfile
= generic_file_sendfile
,
261 struct inode_operations udf_file_inode_operations
= {
262 .truncate
= udf_truncate
,