~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/udf/file.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/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/buffer_head.h>
 37 #include <linux/aio.h>
 38 
 39 #include "udf_i.h"
 40 #include "udf_sb.h"
 41 
 42 static void __udf_adinicb_readpage(struct page *page)
 43 {
 44         struct inode *inode = page->mapping->host;
 45         char *kaddr;
 46         struct udf_inode_info *iinfo = UDF_I(inode);
 47 
 48         kaddr = kmap(page);
 49         memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr, inode->i_size);
 50         memset(kaddr + inode->i_size, 0, PAGE_CACHE_SIZE - inode->i_size);
 51         flush_dcache_page(page);
 52         SetPageUptodate(page);
 53         kunmap(page);
 54 }
 55 
 56 static int udf_adinicb_readpage(struct file *file, struct page *page)
 57 {
 58         BUG_ON(!PageLocked(page));
 59         __udf_adinicb_readpage(page);
 60         unlock_page(page);
 61 
 62         return 0;
 63 }
 64 
 65 static int udf_adinicb_writepage(struct page *page,
 66                                  struct writeback_control *wbc)
 67 {
 68         struct inode *inode = page->mapping->host;
 69         char *kaddr;
 70         struct udf_inode_info *iinfo = UDF_I(inode);
 71 
 72         BUG_ON(!PageLocked(page));
 73 
 74         kaddr = kmap(page);
 75         memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr, inode->i_size);
 76         mark_inode_dirty(inode);
 77         SetPageUptodate(page);
 78         kunmap(page);
 79         unlock_page(page);
 80 
 81         return 0;
 82 }
 83 
 84 static int udf_adinicb_write_begin(struct file *file,
 85                         struct address_space *mapping, loff_t pos,
 86                         unsigned len, unsigned flags, struct page **pagep,
 87                         void **fsdata)
 88 {
 89         struct page *page;
 90 
 91         if (WARN_ON_ONCE(pos >= PAGE_CACHE_SIZE))
 92                 return -EIO;
 93         page = grab_cache_page_write_begin(mapping, 0, flags);
 94         if (!page)
 95                 return -ENOMEM;
 96         *pagep = page;
 97 
 98         if (!PageUptodate(page) && len != PAGE_CACHE_SIZE)
 99                 __udf_adinicb_readpage(page);
100         return 0;
101 }
102 
103 static ssize_t udf_adinicb_direct_IO(int rw, struct kiocb *iocb,
104                                      struct iov_iter *iter,
105                                      loff_t offset)
106 {
107         /* Fallback to buffered I/O. */
108         return 0;
109 }
110 
111 const struct address_space_operations udf_adinicb_aops = {
112         .readpage       = udf_adinicb_readpage,
113         .writepage      = udf_adinicb_writepage,
114         .write_begin    = udf_adinicb_write_begin,
115         .write_end      = simple_write_end,
116         .direct_IO      = udf_adinicb_direct_IO,
117 };
118 
119 static ssize_t udf_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
120 {
121         ssize_t retval;
122         struct file *file = iocb->ki_filp;
123         struct inode *inode = file_inode(file);
124         int err, pos;
125         size_t count = iocb->ki_nbytes;
126         struct udf_inode_info *iinfo = UDF_I(inode);
127 
128         mutex_lock(&inode->i_mutex);
129         down_write(&iinfo->i_data_sem);
130         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
131                 if (file->f_flags & O_APPEND)
132                         pos = inode->i_size;
133                 else
134                         pos = iocb->ki_pos;
135 
136                 if (inode->i_sb->s_blocksize <
137                                 (udf_file_entry_alloc_offset(inode) +
138                                                 pos + count)) {
139                         err = udf_expand_file_adinicb(inode);
140                         if (err) {
141                                 mutex_unlock(&inode->i_mutex);
142                                 udf_debug("udf_expand_adinicb: err=%d\n", err);
143                                 return err;
144                         }
145                 } else {
146                         if (pos + count > inode->i_size)
147                                 iinfo->i_lenAlloc = pos + count;
148                         else
149                                 iinfo->i_lenAlloc = inode->i_size;
150                         up_write(&iinfo->i_data_sem);
151                 }
152         } else
153                 up_write(&iinfo->i_data_sem);
154 
155         retval = __generic_file_write_iter(iocb, from);
156         mutex_unlock(&inode->i_mutex);
157 
158         if (retval > 0) {
159                 ssize_t err;
160 
161                 mark_inode_dirty(inode);
162                 err = generic_write_sync(file, iocb->ki_pos - retval, retval);
163                 if (err < 0)
164                         retval = err;
165         }
166 
167         return retval;
168 }
169 
170 long udf_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
171 {
172         struct inode *inode = file_inode(filp);
173         long old_block, new_block;
174         int result = -EINVAL;
175 
176         if (inode_permission(inode, MAY_READ) != 0) {
177                 udf_debug("no permission to access inode %lu\n", inode->i_ino);
178                 result = -EPERM;
179                 goto out;
180         }
181 
182         if (!arg) {
183                 udf_debug("invalid argument to udf_ioctl\n");
184                 result = -EINVAL;
185                 goto out;
186         }
187 
188         switch (cmd) {
189         case UDF_GETVOLIDENT:
190                 if (copy_to_user((char __user *)arg,
191                                  UDF_SB(inode->i_sb)->s_volume_ident, 32))
192                         result = -EFAULT;
193                 else
194                         result = 0;
195                 goto out;
196         case UDF_RELOCATE_BLOCKS:
197                 if (!capable(CAP_SYS_ADMIN)) {
198                         result = -EPERM;
199                         goto out;
200                 }
201                 if (get_user(old_block, (long __user *)arg)) {
202                         result = -EFAULT;
203                         goto out;
204                 }
205                 result = udf_relocate_blocks(inode->i_sb,
206                                                 old_block, &new_block);
207                 if (result == 0)
208                         result = put_user(new_block, (long __user *)arg);
209                 goto out;
210         case UDF_GETEASIZE:
211                 result = put_user(UDF_I(inode)->i_lenEAttr, (int __user *)arg);
212                 goto out;
213         case UDF_GETEABLOCK:
214                 result = copy_to_user((char __user *)arg,
215                                       UDF_I(inode)->i_ext.i_data,
216                                       UDF_I(inode)->i_lenEAttr) ? -EFAULT : 0;
217                 goto out;
218         }
219 
220 out:
221         return result;
222 }
223 
224 static int udf_release_file(struct inode *inode, struct file *filp)
225 {
226         if (filp->f_mode & FMODE_WRITE &&
227             atomic_read(&inode->i_writecount) == 1) {
228                 /*
229                  * Grab i_mutex to avoid races with writes changing i_size
230                  * while we are running.
231                  */
232                 mutex_lock(&inode->i_mutex);
233                 down_write(&UDF_I(inode)->i_data_sem);
234                 udf_discard_prealloc(inode);
235                 udf_truncate_tail_extent(inode);
236                 up_write(&UDF_I(inode)->i_data_sem);
237                 mutex_unlock(&inode->i_mutex);
238         }
239         return 0;
240 }
241 
242 const struct file_operations udf_file_operations = {
243         .read                   = new_sync_read,
244         .read_iter              = generic_file_read_iter,
245         .unlocked_ioctl         = udf_ioctl,
246         .open                   = generic_file_open,
247         .mmap                   = generic_file_mmap,
248         .write                  = new_sync_write,
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,
254 };
255 
256 static int udf_setattr(struct dentry *dentry, struct iattr *attr)
257 {
258         struct inode *inode = dentry->d_inode;
259         int error;
260 
261         error = inode_change_ok(inode, attr);
262         if (error)
263                 return error;
264 
265         if ((attr->ia_valid & ATTR_SIZE) &&
266             attr->ia_size != i_size_read(inode)) {
267                 error = udf_setsize(inode, attr->ia_size);
268                 if (error)
269                         return error;
270         }
271 
272         setattr_copy(inode, attr);
273         mark_inode_dirty(inode);
274         return 0;
275 }
276 
277 const struct inode_operations udf_file_inode_operations = {
278         .setattr                = udf_setattr,
279 };
280 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp