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

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

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: MIT
  2 /*
  3  * VirtualBox Guest Shared Folders support: Regular file inode and file ops.
  4  *
  5  * Copyright (C) 2006-2018 Oracle Corporation
  6  */
  7 
  8 #include <linux/mm.h>
  9 #include <linux/page-flags.h>
 10 #include <linux/pagemap.h>
 11 #include <linux/highmem.h>
 12 #include <linux/sizes.h>
 13 #include "vfsmod.h"
 14 
 15 struct vboxsf_handle {
 16         u64 handle;
 17         u32 root;
 18         u32 access_flags;
 19         struct kref refcount;
 20         struct list_head head;
 21 };
 22 
 23 static int vboxsf_file_open(struct inode *inode, struct file *file)
 24 {
 25         struct vboxsf_inode *sf_i = VBOXSF_I(inode);
 26         struct shfl_createparms params = {};
 27         struct vboxsf_handle *sf_handle;
 28         u32 access_flags = 0;
 29         int err;
 30 
 31         sf_handle = kmalloc(sizeof(*sf_handle), GFP_KERNEL);
 32         if (!sf_handle)
 33                 return -ENOMEM;
 34 
 35         /*
 36          * We check the value of params.handle afterwards to find out if
 37          * the call succeeded or failed, as the API does not seem to cleanly
 38          * distinguish error and informational messages.
 39          *
 40          * Furthermore, we must set params.handle to SHFL_HANDLE_NIL to
 41          * make the shared folders host service use our mode parameter.
 42          */
 43         params.handle = SHFL_HANDLE_NIL;
 44         if (file->f_flags & O_CREAT) {
 45                 params.create_flags |= SHFL_CF_ACT_CREATE_IF_NEW;
 46                 /*
 47                  * We ignore O_EXCL, as the Linux kernel seems to call create
 48                  * beforehand itself, so O_EXCL should always fail.
 49                  */
 50                 if (file->f_flags & O_TRUNC)
 51                         params.create_flags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
 52                 else
 53                         params.create_flags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
 54         } else {
 55                 params.create_flags |= SHFL_CF_ACT_FAIL_IF_NEW;
 56                 if (file->f_flags & O_TRUNC)
 57                         params.create_flags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
 58         }
 59 
 60         switch (file->f_flags & O_ACCMODE) {
 61         case O_RDONLY:
 62                 access_flags |= SHFL_CF_ACCESS_READ;
 63                 break;
 64 
 65         case O_WRONLY:
 66                 access_flags |= SHFL_CF_ACCESS_WRITE;
 67                 break;
 68 
 69         case O_RDWR:
 70                 access_flags |= SHFL_CF_ACCESS_READWRITE;
 71                 break;
 72 
 73         default:
 74                 WARN_ON(1);
 75         }
 76 
 77         if (file->f_flags & O_APPEND)
 78                 access_flags |= SHFL_CF_ACCESS_APPEND;
 79 
 80         params.create_flags |= access_flags;
 81         params.info.attr.mode = inode->i_mode;
 82 
 83         err = vboxsf_create_at_dentry(file_dentry(file), &params);
 84         if (err == 0 && params.handle == SHFL_HANDLE_NIL)
 85                 err = (params.result == SHFL_FILE_EXISTS) ? -EEXIST : -ENOENT;
 86         if (err) {
 87                 kfree(sf_handle);
 88                 return err;
 89         }
 90 
 91         /* the host may have given us different attr then requested */
 92         sf_i->force_restat = 1;
 93 
 94         /* init our handle struct and add it to the inode's handles list */
 95         sf_handle->handle = params.handle;
 96         sf_handle->root = VBOXSF_SBI(inode->i_sb)->root;
 97         sf_handle->access_flags = access_flags;
 98         kref_init(&sf_handle->refcount);
 99 
100         mutex_lock(&sf_i->handle_list_mutex);
101         list_add(&sf_handle->head, &sf_i->handle_list);
102         mutex_unlock(&sf_i->handle_list_mutex);
103 
104         file->private_data = sf_handle;
105         return 0;
106 }
107 
108 static void vboxsf_handle_release(struct kref *refcount)
109 {
110         struct vboxsf_handle *sf_handle =
111                 container_of(refcount, struct vboxsf_handle, refcount);
112 
113         vboxsf_close(sf_handle->root, sf_handle->handle);
114         kfree(sf_handle);
115 }
116 
117 static int vboxsf_file_release(struct inode *inode, struct file *file)
118 {
119         struct vboxsf_inode *sf_i = VBOXSF_I(inode);
120         struct vboxsf_handle *sf_handle = file->private_data;
121 
122         /*
123          * When a file is closed on our (the guest) side, we want any subsequent
124          * accesses done on the host side to see all changes done from our side.
125          */
126         filemap_write_and_wait(inode->i_mapping);
127 
128         mutex_lock(&sf_i->handle_list_mutex);
129         list_del(&sf_handle->head);
130         mutex_unlock(&sf_i->handle_list_mutex);
131 
132         kref_put(&sf_handle->refcount, vboxsf_handle_release);
133         return 0;
134 }
135 
136 /*
137  * Write back dirty pages now, because there may not be any suitable
138  * open files later
139  */
140 static void vboxsf_vma_close(struct vm_area_struct *vma)
141 {
142         filemap_write_and_wait(vma->vm_file->f_mapping);
143 }
144 
145 static const struct vm_operations_struct vboxsf_file_vm_ops = {
146         .close          = vboxsf_vma_close,
147         .fault          = filemap_fault,
148         .map_pages      = filemap_map_pages,
149 };
150 
151 static int vboxsf_file_mmap(struct file *file, struct vm_area_struct *vma)
152 {
153         int err;
154 
155         err = generic_file_mmap(file, vma);
156         if (!err)
157                 vma->vm_ops = &vboxsf_file_vm_ops;
158 
159         return err;
160 }
161 
162 /*
163  * Note that since we are accessing files on the host's filesystem, files
164  * may always be changed underneath us by the host!
165  *
166  * The vboxsf API between the guest and the host does not offer any functions
167  * to deal with this. There is no inode-generation to check for changes, no
168  * events / callback on changes and no way to lock files.
169  *
170  * To avoid returning stale data when a file gets *opened* on our (the guest)
171  * side, we do a "stat" on the host side, then compare the mtime with the
172  * last known mtime and invalidate the page-cache if they differ.
173  * This is done from vboxsf_inode_revalidate().
174  *
175  * When reads are done through the read_iter fop, it is possible to do
176  * further cache revalidation then, there are 3 options to deal with this:
177  *
178  * 1)  Rely solely on the revalidation done at open time
179  * 2)  Do another "stat" and compare mtime again. Unfortunately the vboxsf
180  *     host API does not allow stat on handles, so we would need to use
181  *     file->f_path.dentry and the stat will then fail if the file was unlinked
182  *     or renamed (and there is no thing like NFS' silly-rename). So we get:
183  * 2a) "stat" and compare mtime, on stat failure invalidate the cache
184  * 2b) "stat" and compare mtime, on stat failure do nothing
185  * 3)  Simply always call invalidate_inode_pages2_range on the range of the read
186  *
187  * Currently we are keeping things KISS and using option 1. this allows
188  * directly using generic_file_read_iter without wrapping it.
189  *
190  * This means that only data written on the host side before open() on
191  * the guest side is guaranteed to be seen by the guest. If necessary
192  * we may provide other read-cache strategies in the future and make this
193  * configurable through a mount option.
194  */
195 const struct file_operations vboxsf_reg_fops = {
196         .llseek = generic_file_llseek,
197         .read_iter = generic_file_read_iter,
198         .write_iter = generic_file_write_iter,
199         .mmap = vboxsf_file_mmap,
200         .open = vboxsf_file_open,
201         .release = vboxsf_file_release,
202         .fsync = noop_fsync,
203         .splice_read = generic_file_splice_read,
204 };
205 
206 const struct inode_operations vboxsf_reg_iops = {
207         .getattr = vboxsf_getattr,
208         .setattr = vboxsf_setattr
209 };
210 
211 static int vboxsf_readpage(struct file *file, struct page *page)
212 {
213         struct vboxsf_handle *sf_handle = file->private_data;
214         loff_t off = page_offset(page);
215         u32 nread = PAGE_SIZE;
216         u8 *buf;
217         int err;
218 
219         buf = kmap(page);
220 
221         err = vboxsf_read(sf_handle->root, sf_handle->handle, off, &nread, buf);
222         if (err == 0) {
223                 memset(&buf[nread], 0, PAGE_SIZE - nread);
224                 flush_dcache_page(page);
225                 SetPageUptodate(page);
226         } else {
227                 SetPageError(page);
228         }
229 
230         kunmap(page);
231         unlock_page(page);
232         return err;
233 }
234 
235 static struct vboxsf_handle *vboxsf_get_write_handle(struct vboxsf_inode *sf_i)
236 {
237         struct vboxsf_handle *h, *sf_handle = NULL;
238 
239         mutex_lock(&sf_i->handle_list_mutex);
240         list_for_each_entry(h, &sf_i->handle_list, head) {
241                 if (h->access_flags == SHFL_CF_ACCESS_WRITE ||
242                     h->access_flags == SHFL_CF_ACCESS_READWRITE) {
243                         kref_get(&h->refcount);
244                         sf_handle = h;
245                         break;
246                 }
247         }
248         mutex_unlock(&sf_i->handle_list_mutex);
249 
250         return sf_handle;
251 }
252 
253 static int vboxsf_writepage(struct page *page, struct writeback_control *wbc)
254 {
255         struct inode *inode = page->mapping->host;
256         struct vboxsf_inode *sf_i = VBOXSF_I(inode);
257         struct vboxsf_handle *sf_handle;
258         loff_t off = page_offset(page);
259         loff_t size = i_size_read(inode);
260         u32 nwrite = PAGE_SIZE;
261         u8 *buf;
262         int err;
263 
264         if (off + PAGE_SIZE > size)
265                 nwrite = size & ~PAGE_MASK;
266 
267         sf_handle = vboxsf_get_write_handle(sf_i);
268         if (!sf_handle)
269                 return -EBADF;
270 
271         buf = kmap(page);
272         err = vboxsf_write(sf_handle->root, sf_handle->handle,
273                            off, &nwrite, buf);
274         kunmap(page);
275 
276         kref_put(&sf_handle->refcount, vboxsf_handle_release);
277 
278         if (err == 0) {
279                 ClearPageError(page);
280                 /* mtime changed */
281                 sf_i->force_restat = 1;
282         } else {
283                 ClearPageUptodate(page);
284         }
285 
286         unlock_page(page);
287         return err;
288 }
289 
290 static int vboxsf_write_end(struct file *file, struct address_space *mapping,
291                             loff_t pos, unsigned int len, unsigned int copied,
292                             struct page *page, void *fsdata)
293 {
294         struct inode *inode = mapping->host;
295         struct vboxsf_handle *sf_handle = file->private_data;
296         unsigned int from = pos & ~PAGE_MASK;
297         u32 nwritten = len;
298         u8 *buf;
299         int err;
300 
301         /* zero the stale part of the page if we did a short copy */
302         if (!PageUptodate(page) && copied < len)
303                 zero_user(page, from + copied, len - copied);
304 
305         buf = kmap(page);
306         err = vboxsf_write(sf_handle->root, sf_handle->handle,
307                            pos, &nwritten, buf + from);
308         kunmap(page);
309 
310         if (err) {
311                 nwritten = 0;
312                 goto out;
313         }
314 
315         /* mtime changed */
316         VBOXSF_I(inode)->force_restat = 1;
317 
318         if (!PageUptodate(page) && nwritten == PAGE_SIZE)
319                 SetPageUptodate(page);
320 
321         pos += nwritten;
322         if (pos > inode->i_size)
323                 i_size_write(inode, pos);
324 
325 out:
326         unlock_page(page);
327         put_page(page);
328 
329         return nwritten;
330 }
331 
332 /*
333  * Note simple_write_begin does not read the page from disk on partial writes
334  * this is ok since vboxsf_write_end only writes the written parts of the
335  * page and it does not call SetPageUptodate for partial writes.
336  */
337 const struct address_space_operations vboxsf_reg_aops = {
338         .readpage = vboxsf_readpage,
339         .writepage = vboxsf_writepage,
340         .set_page_dirty = __set_page_dirty_nobuffers,
341         .write_begin = simple_write_begin,
342         .write_end = vboxsf_write_end,
343 };
344 
345 static const char *vboxsf_get_link(struct dentry *dentry, struct inode *inode,
346                                    struct delayed_call *done)
347 {
348         struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
349         struct shfl_string *path;
350         char *link;
351         int err;
352 
353         if (!dentry)
354                 return ERR_PTR(-ECHILD);
355 
356         path = vboxsf_path_from_dentry(sbi, dentry);
357         if (IS_ERR(path))
358                 return ERR_CAST(path);
359 
360         link = kzalloc(PATH_MAX, GFP_KERNEL);
361         if (!link) {
362                 __putname(path);
363                 return ERR_PTR(-ENOMEM);
364         }
365 
366         err = vboxsf_readlink(sbi->root, path, PATH_MAX, link);
367         __putname(path);
368         if (err) {
369                 kfree(link);
370                 return ERR_PTR(err);
371         }
372 
373         set_delayed_call(done, kfree_link, link);
374         return link;
375 }
376 
377 const struct inode_operations vboxsf_lnk_iops = {
378         .get_link = vboxsf_get_link
379 };
380 

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