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

~ [ 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