| blob | ae2fe0016d2c7be63adf1029f878b798fa1af7b6 |
1 /*
2 * file.c - NTFS kernel file operations. Part of the Linux-NTFS project.
3 *
4 * Copyright (c) 2001-2006 Anton Altaparmakov
5 *
6 * This program/include file is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as published
8 * by the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program/include file is distributed in the hope that it will be
12 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program (in the main directory of the Linux-NTFS
18 * distribution in the file COPYING); if not, write to the Free Software
19 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
22 #include <linux/buffer_head.h>
23 #include <linux/pagemap.h>
24 #include <linux/pagevec.h>
25 #include <linux/sched.h>
26 #include <linux/swap.h>
27 #include <linux/uio.h>
28 #include <linux/writeback.h>
30 #include <asm/page.h>
31 #include <asm/uaccess.h>
42 /**
43 * ntfs_file_open - called when an inode is about to be opened
44 * @vi: inode to be opened
45 * @filp: file structure describing the inode
46 *
47 * Limit file size to the page cache limit on architectures where unsigned long
48 * is 32-bits. This is the most we can do for now without overflowing the page
49 * cache page index. Doing it this way means we don't run into problems because
50 * of existing too large files. It would be better to allow the user to read
51 * the beginning of the file but I doubt very much anyone is going to hit this
52 * check on a 32-bit architecture, so there is no point in adding the extra
53 * complexity required to support this.
54 *
55 * On 64-bit architectures, the check is hopefully optimized away by the
56 * compiler.
57 *
58 * After the check passes, just call generic_file_open() to do its work.
59 */
61 {
65 }
67 }
69 #ifdef NTFS_RW
71 /**
72 * ntfs_attr_extend_initialized - extend the initialized size of an attribute
73 * @ni: ntfs inode of the attribute to extend
74 * @new_init_size: requested new initialized size in bytes
75 * @cached_page: store any allocated but unused page here
76 * @lru_pvec: lru-buffering pagevec of the caller
77 *
78 * Extend the initialized size of an attribute described by the ntfs inode @ni
79 * to @new_init_size bytes. This involves zeroing any non-sparse space between
80 * the old initialized size and @new_init_size both in the page cache and on
81 * disk (if relevant complete pages are already uptodate in the page cache then
82 * these are simply marked dirty).
83 *
84 * As a side-effect, the file size (vfs inode->i_size) may be incremented as,
85 * in the resident attribute case, it is tied to the initialized size and, in
86 * the non-resident attribute case, it may not fall below the initialized size.
87 *
88 * Note that if the attribute is resident, we do not need to touch the page
89 * cache at all. This is because if the page cache page is not uptodate we
90 * bring it uptodate later, when doing the write to the mft record since we
91 * then already have the page mapped. And if the page is uptodate, the
92 * non-initialized region will already have been zeroed when the page was
93 * brought uptodate and the region may in fact already have been overwritten
94 * with new data via mmap() based writes, so we cannot just zero it. And since
95 * POSIX specifies that the behaviour of resizing a file whilst it is mmap()ped
96 * is unspecified, we choose not to do zeroing and thus we do not need to touch
97 * the page at all. For a more detailed explanation see ntfs_truncate() in
98 * fs/ntfs/inode.c.
99 *
100 * @cached_page and @lru_pvec are just optimizations for dealing with multiple
101 * pages.
102 *
103 * Return 0 on success and -errno on error. In the case that an error is
104 * encountered it is possible that the initialized size will already have been
105 * incremented some way towards @new_init_size but it is guaranteed that if
106 * this is the case, the necessary zeroing will also have happened and that all
107 * metadata is self-consistent.
108 *
109 * Locking: i_mutex on the vfs inode corrseponsind to the ntfs inode @ni must be
110 * held by the caller.
111 */
114 {
115 s64 old_init_size;
116 loff_t old_i_size;
128 u32 attr_len;
136 "old_initialized_size 0x%llx, "
143 else
145 /* Use goto to reduce indentation and we need the label below anyway. */
154 }
159 }
166 }
170 /* The total length of the attribute value. */
173 /*
174 * Do the zeroing in the mft record and update the attribute size in
175 * the mft record.
176 */
180 /* Finally, update the sizes in the vfs and ntfs inodes. */
186 do_non_resident_extend:
187 /*
188 * If the new initialized size @new_init_size exceeds the current file
189 * size (vfs inode->i_size), we need to extend the file size to the
190 * new initialized size.
191 */
198 }
203 }
210 }
219 /* Update the file size in the vfs inode. */
225 }
230 /*
231 * Read the page. If the page is not present, this will zero
232 * the uninitialized regions for us.
233 */
238 }
244 }
245 /*
246 * Update the initialized size in the ntfs inode. This is
247 * enough to make ntfs_writepage() work.
248 */
254 /* Set the page dirty so it gets written out. */
257 /*
258 * Play nice with the vm and the rest of the system. This is
259 * very much needed as we can potentially be modifying the
260 * initialised size from a very small value to a really huge
261 * value, e.g.
262 * f = open(somefile, O_TRUNC);
263 * truncate(f, 10GiB);
264 * seek(f, 10GiB);
265 * write(f, 1);
266 * And this would mean we would be marking dirty hundreds of
267 * thousands of pages or as in the above example more than
268 * two and a half million pages!
269 *
270 * TODO: For sparse pages could optimize this workload by using
271 * the FsMisc / MiscFs page bit as a "PageIsSparse" bit. This
272 * would be set in readpage for sparse pages and here we would
273 * not need to mark dirty any pages which have this bit set.
274 * The only caveat is that we have to clear the bit everywhere
275 * where we allocate any clusters that lie in the page or that
276 * contain the page.
277 *
278 * TODO: An even greater optimization would be for us to only
279 * call readpage() on pages which are not in sparse regions as
280 * determined from the runlist. This would greatly reduce the
281 * number of pages we read and make dirty in the case of sparse
282 * files.
283 */
290 /* Now bring in sync the initialized_size in the mft record. */
296 }
301 }
308 }
313 done:
323 init_err_out:
327 err_out:
334 }
336 /**
337 * ntfs_fault_in_pages_readable -
338 *
339 * Fault a number of userspace pages into pagetables.
340 *
341 * Unlike include/linux/pagemap.h::fault_in_pages_readable(), this one copes
342 * with more than two userspace pages as well as handling the single page case
343 * elegantly.
344 *
345 * If you find this difficult to understand, then think of the while loop being
346 * the following code, except that we do without the integer variable ret:
347 *
348 * do {
349 * ret = __get_user(c, uaddr);
350 * uaddr += PAGE_SIZE;
351 * } while (!ret && uaddr < end);
352 *
353 * Note, the final __get_user() may well run out-of-bounds of the user buffer,
354 * but _not_ out-of-bounds of the page the user buffer belongs to, and since
355 * this is only a read and not a write, and since it is still in the same page,
356 * it should not matter and this makes the code much simpler.
357 */
360 {
364 /* Set @end to the first byte outside the last page we care about. */
368 ;
369 }
371 /**
372 * ntfs_fault_in_pages_readable_iovec -
373 *
374 * Same as ntfs_fault_in_pages_readable() but operates on an array of iovecs.
375 */
378 {
389 iov++;
392 }
394 /**
395 * __ntfs_grab_cache_pages - obtain a number of locked pages
396 * @mapping: address space mapping from which to obtain page cache pages
397 * @index: starting index in @mapping at which to begin obtaining pages
398 * @nr_pages: number of page cache pages to obtain
399 * @pages: array of pages in which to return the obtained page cache pages
400 * @cached_page: allocated but as yet unused page
401 * @lru_pvec: lru-buffering pagevec of caller
402 *
403 * Obtain @nr_pages locked page cache pages from the mapping @maping and
404 * starting at index @index.
405 *
406 * If a page is newly created, increment its refcount and add it to the
407 * caller's lru-buffering pagevec @lru_pvec.
408 *
409 * This is the same as mm/filemap.c::__grab_cache_page(), except that @nr_pages
410 * are obtained at once instead of just one page and that 0 is returned on
411 * success and -errno on error.
412 *
413 * Note, the page locks are obtained in ascending page index order.
414 */
418 {
431 }
432 }
434 GFP_KERNEL);
439 }
445 }
446 index++;
447 nr++;
449 out:
451 err_out:
455 }
457 }
460 {
465 }
467 /**
468 * ntfs_prepare_pages_for_non_resident_write - prepare pages for receiving data
469 * @pages: array of destination pages
470 * @nr_pages: number of pages in @pages
471 * @pos: byte position in file at which the write begins
472 * @bytes: number of bytes to be written
473 *
474 * This is called for non-resident attributes from ntfs_file_buffered_write()
475 * with i_mutex held on the inode (@pages[0]->mapping->host). There are
476 * @nr_pages pages in @pages which are locked but not kmap()ped. The source
477 * data has not yet been copied into the @pages.
478 *
479 * Need to fill any holes with actual clusters, allocate buffers if necessary,
480 * ensure all the buffers are mapped, and bring uptodate any buffers that are
481 * only partially being written to.
482 *
483 * If @nr_pages is greater than one, we are guaranteed that the cluster size is
484 * greater than PAGE_CACHE_SIZE, that all pages in @pages are entirely inside
485 * the same cluster and that they are the entirety of that cluster, and that
486 * the cluster is sparse, i.e. we need to allocate a cluster to fill the hole.
487 *
488 * i_size is not to be modified yet.
489 *
490 * Return 0 on success or -errno on error.
491 */
494 {
496 LCN lcn;
498 sector_t lcn_block;
536 /*
537 * create_empty_buffers() will create uptodate/dirty buffers if
538 * the page is uptodate/dirty.
539 */
544 }
556 /*
557 * Loop over each page and for each page over each buffer. Use goto to
558 * reduce indentation.
559 */
561 do_next_page:
566 VCN cdelta;
567 s64 bh_end;
570 /* Clear buffer_new on all buffers to reinitialise state. */
577 /*
578 * The buffer is already mapped. If it is uptodate,
579 * ignore it.
580 */
583 /*
584 * The buffer is not uptodate. If the page is uptodate
585 * set the buffer uptodate and otherwise ignore it.
586 */
590 }
591 /*
592 * Neither the page nor the buffer are uptodate. If
593 * the buffer is only partially being written to, we
594 * need to read it in before the write, i.e. now.
595 */
598 /*
599 * If the buffer is fully or partially within
600 * the initialized size, do an actual read.
601 * Otherwise, simply zero the buffer.
602 */
612 blocksize);
616 }
617 }
619 }
620 /* Unmapped buffer. Need to map it. */
622 /*
623 * If the current buffer is in the same clusters as the map
624 * cache, there is no need to check the runlist again. The
625 * map cache is made up of @vcn, which is the first cached file
626 * cluster, @vcn_len which is the number of cached file
627 * clusters, @lcn is the device cluster corresponding to @vcn,
628 * and @lcn_block is the block number corresponding to @lcn.
629 */
632 map_buffer_cached:
636 blocksize_bits)) +
639 /*
640 * If the page is uptodate so is the buffer. If the
641 * buffer is fully outside the write, we ignore it if
642 * it was already allocated and we mark it dirty so it
643 * gets written out if we allocated it. On the other
644 * hand, if we allocated the buffer but we are not
645 * marking it dirty we set buffer_new so we can do
646 * error recovery.
647 */
652 /* We allocated the buffer. */
657 else
659 }
661 }
662 /* Page is _not_ uptodate. */
664 /*
665 * Buffer was already allocated. If it is not
666 * uptodate and is only partially being written
667 * to, we need to read it in before the write,
668 * i.e. now.
669 */
674 /*
675 * If the buffer is fully or partially
676 * within the initialized size, do an
677 * actual read. Otherwise, simply zero
678 * the buffer.
679 */
681 flags);
684 flags);
690 KM_USER0);
696 }
697 }
699 }
700 /* We allocated the buffer. */
702 /*
703 * If the buffer is fully outside the write, zero it,
704 * set it uptodate, and mark it dirty so it gets
705 * written out. If it is partially being written to,
706 * zero region surrounding the write but leave it to
707 * commit write to do anything else. Finally, if the
708 * buffer is fully being overwritten, do nothing.
709 */
714 blocksize);
718 }
721 }
732 }
736 }
739 }
741 }
742 /*
743 * Slow path: this is the first buffer in the cluster. If it
744 * is outside allocated size and is not uptodate, zero it and
745 * set it uptodate.
746 */
760 }
762 }
766 retry_remap:
768 }
770 /* Seek to element containing target cluster. */
772 rl++;
775 /*
776 * Successful remap, setup the map cache and
777 * use that to deal with the buffer.
778 */
783 blocksize_bits);
785 /*
786 * If the number of remaining clusters touched
787 * by the write is smaller or equal to the
788 * number of cached clusters, unlock the
789 * runlist as the map cache will be used from
790 * now on.
791 */
799 }
801 }
804 /*
805 * If it is not a hole and not out of bounds, the runlist is
806 * probably unmapped so try to map it now.
807 */
810 /* Attempt to map runlist. */
812 /*
813 * We need the runlist locked for
814 * writing, so if it is locked for
815 * reading relock it now and retry in
816 * case it changed whilst we dropped
817 * the lock.
818 */
823 }
825 NULL);
829 }
830 /*
831 * If @vcn is out of bounds, pretend @lcn is
832 * LCN_ENOENT. As long as the buffer is out
833 * of bounds this will work fine.
834 */
839 }
842 /* Failed to map the buffer, even after retrying. */
845 "attribute type 0x%x, vcn 0x%llx, "
846 "vcn offset 0x%x, because its "
847 "location on disk could not be "
854 err);
856 }
857 rl_not_mapped_enoent:
858 /*
859 * The buffer is in a hole or out of bounds. We need to fill
860 * the hole, unless the buffer is in a cluster which is not
861 * touched by the write, in which case we just leave the buffer
862 * unmapped. This can only happen when the cluster size is
863 * less than the page cache size.
864 */
870 /*
871 * If the buffer is uptodate we skip it. If it
872 * is not but the page is uptodate, we can set
873 * the buffer uptodate. If the page is not
874 * uptodate, we can clear the buffer and set it
875 * uptodate. Whether this is worthwhile is
876 * debatable and this could be removed.
877 */
884 blocksize);
888 }
890 }
891 }
892 /*
893 * Out of bounds buffer is invalid if it was not really out of
894 * bounds.
895 */
897 /*
898 * We need the runlist locked for writing, so if it is locked
899 * for reading relock it now and retry in case it changed
900 * whilst we dropped the lock.
901 */
908 }
909 /* Find the previous last allocated cluster. */
917 }
918 }
924 err);
926 }
935 "allocated cluster in error "
936 "code path. Run chkdsk to "
939 }
942 }
947 /* Map and lock the mft record and get the attribute record. */
950 else
956 }
962 }
970 }
973 /*
974 * Find the runlist element with which the attribute extent
975 * starts. Note, we cannot use the _attr_ version because we
976 * have mapped the mft record. That is ok because we know the
977 * runlist fragment must be mapped already to have ever gotten
978 * here, so we can just use the _rl_ version.
979 */
986 /*
987 * If @highest_vcn is zero, calculate the real highest_vcn
988 * (which can really be zero).
989 */
994 /*
995 * Determine the size of the mapping pairs array for the new
996 * extent, i.e. the old extent with the hole filled.
997 */
999 highest_vcn);
1006 }
1007 /*
1008 * Resize the attribute record to fit the new mapping pairs
1009 * array.
1010 */
1016 // TODO: Deal with this by using the current attribute
1017 // and fill it with as much of the mapping pairs
1018 // array as possible. Then loop over each attribute
1019 // extent rewriting the mapping pairs arrays as we go
1020 // along and if when we reach the end we have not
1021 // enough space, try to resize the last attribute
1022 // extent and if even that fails, add a new attribute
1023 // extent.
1024 // We could also try to resize at each step in the hope
1025 // that we will not need to rewrite every single extent.
1026 // Note, we may need to decompress some extents to fill
1027 // the runlist as we are walking the extents...
1029 "record for the extended attribute "
1030 "record. This case is not "
1034 }
1036 /*
1037 * Generate the mapping pairs array directly into the attribute
1038 * record.
1039 */
1045 "attribute type 0x%x, because building "
1046 "the mapping pairs failed with error "
1051 }
1052 /* Update the highest_vcn but only if it was not set. */
1056 /*
1057 * If the attribute is sparse/compressed, update the compressed
1058 * size in the ntfs_inode structure and the attribute record.
1059 */
1061 /*
1062 * If we are not in the first attribute extent, switch
1063 * to it, but first ensure the changes will make it to
1064 * disk later.
1065 */
1076 }
1077 /* @m is not used any more so do not set it. */
1079 }
1085 }
1086 /* Ensure the changes make it to disk. */
1091 /* Successfully filled the hole. */
1095 /* Setup the map cache and use that to deal with the buffer. */
1101 /*
1102 * If the number of remaining clusters in the @pages is smaller
1103 * or equal to the number of cached clusters, unlock the
1104 * runlist as the map cache will be used from now on.
1105 */
1110 }
1113 /* If there are no errors, do the next page. */
1116 /* If there are no errors, release the runlist lock if we took it. */
1124 }
1125 /* If we issued read requests, let them complete. */
1136 /*
1137 * If the buffer overflows the initialized size, need
1138 * to zero the overflowing region.
1139 */
1151 }
1154 }
1156 /* Clear buffer_new on all buffers. */
1167 }
1169 /* Get back to the attribute extent we modified. */
1174 "attribute extent of attribute in "
1175 "error code path. Run chkdsk to "
1182 /*
1183 * The only thing that is now wrong is the compressed
1184 * size of the base attribute extent which chkdsk
1185 * should be able to fix.
1186 */
1192 }
1193 }
1194 /*
1195 * If the runlist has been modified, need to restore it by punching a
1196 * hole into it and we then need to deallocate the on-disk cluster as
1197 * well. Note, we only modify the runlist if we are able to generate a
1198 * new mapping pairs array, i.e. only when the mapped attribute extent
1199 * is not switched.
1200 */
1203 /* Make the file cluster we allocated sparse in the runlist. */
1206 "attribute runlist in error code "
1207 "path. Run chkdsk to recover the "
1212 /*
1213 * Deallocate the on-disk cluster we allocated but only
1214 * if we succeeded in punching its vcn out of the
1215 * runlist.
1216 */
1220 "allocated cluster in error "
1221 "code path. Run chkdsk to "
1224 }
1226 }
1227 }
1228 /*
1229 * Resize the attribute record to its old size and rebuild the mapping
1230 * pairs array. Note, we only can do this if the runlist has been
1231 * restored to its old state which also implies that the mapped
1232 * attribute extent is not switched.
1233 */
1237 "record in error code path. Run "
1248 "mapping pairs array in error "
1249 "code path. Run chkdsk to "
1252 }
1255 }
1256 }
1257 /* Release the mft record and the attribute. */
1261 }
1262 /* Release the runlist lock. */
1267 /*
1268 * Zero out any newly allocated blocks to avoid exposing stale data.
1269 * If BH_New is set, we know that the block was newly allocated above
1270 * and that it has not been fully zeroed and marked dirty yet.
1271 */
1292 blocksize);
1296 }
1297 }
1303 }
1305 /*
1306 * Copy as much as we can into the pages and return the number of bytes which
1307 * were sucessfully copied. If a fault is encountered then clear the pages
1308 * out to (ofs + bytes) and return the number of bytes which were copied.
1309 */
1313 {
1328 /* Do it the slow way. */
1334 }
1342 out:
1344 err_out:
1346 /* Zero the rest of the target like __copy_from_user(). */
1357 }
1359 }
1363 {
1381 }
1384 iov++;
1386 }
1388 }
1392 {
1405 iov++;
1407 }
1408 }
1411 }
1413 /*
1414 * This has the same side-effects and return value as ntfs_copy_from_user().
1415 * The difference is that on a fault we need to memset the remainder of the
1416 * pages (out to offset + bytes), to emulate ntfs_copy_from_user()'s
1417 * single-segment behaviour.
1418 *
1419 * We call the same helper (__ntfs_copy_from_user_iovec_inatomic()) both
1420 * when atomic and when not atomic. This is ok because
1421 * __ntfs_copy_from_user_iovec_inatomic() calls __copy_from_user_inatomic()
1422 * and it is ok to call this when non-atomic.
1423 * Infact, the only difference between __copy_from_user_inatomic() and
1424 * __copy_from_user() is that the latter calls might_sleep() and the former
1425 * should not zero the tail of the buffer on error. And on many
1426 * architectures __copy_from_user_inatomic() is just defined to
1427 * __copy_from_user() so it makes no difference at all on those architectures.
1428 */
1432 {
1446 /* Do it the slow way. */
1450 /*
1451 * Zero the rest of the target like __copy_from_user().
1452 */
1457 }
1465 out:
1467 err_out:
1469 /* Zero the rest of the target like __copy_from_user(). */
1480 }
1482 }
1486 {
1488 /*
1489 * Warning: Do not do the decrement at the same time as the call to
1490 * flush_dcache_page() because it is a NULL macro on i386 and hence the
1491 * decrement never happens so the loop never terminates.
1492 */
1497 }
1499 /**
1500 * ntfs_commit_pages_after_non_resident_write - commit the received data
1501 * @pages: array of destination pages
1502 * @nr_pages: number of pages in @pages
1503 * @pos: byte position in file at which the write begins
1504 * @bytes: number of bytes to be written
1505 *
1506 * See description of ntfs_commit_pages_after_write(), below.
1507 */
1511 {
1529 s64 bh_pos;
1538 s64 bh_end;
1547 }
1549 /*
1550 * If all buffers are now uptodate but the page is not, set the
1551 * page uptodate.
1552 */
1556 /*
1557 * Finally, if we do not need to update initialized_size or i_size we
1558 * are finished.
1559 */
1566 }
1567 /*
1568 * Update initialized_size/i_size as appropriate, both in the inode and
1569 * the mft record.
1570 */
1573 else
1575 /* Map, pin, and lock the mft record. */
1582 }
1588 }
1595 }
1606 }
1608 /* Mark the mft record dirty, so it gets written back. */
1615 err_out:
1625 }
1627 /**
1628 * ntfs_commit_pages_after_write - commit the received data
1629 * @pages: array of destination pages
1630 * @nr_pages: number of pages in @pages
1631 * @pos: byte position in file at which the write begins
1632 * @bytes: number of bytes to be written
1633 *
1634 * This is called from ntfs_file_buffered_write() with i_mutex held on the inode
1635 * (@pages[0]->mapping->host). There are @nr_pages pages in @pages which are
1636 * locked but not kmap()ped. The source data has already been copied into the
1637 * @page. ntfs_prepare_pages_for_non_resident_write() has been called before
1638 * the data was copied (for non-resident attributes only) and it returned
1639 * success.
1640 *
1641 * Need to set uptodate and mark dirty all buffers within the boundary of the
1642 * write. If all buffers in a page are uptodate we set the page uptodate, too.
1643 *
1644 * Setting the buffers dirty ensures that they get written out later when
1645 * ntfs_writepage() is invoked by the VM.
1646 *
1647 * Finally, we need to update i_size and initialized_size as appropriate both
1648 * in the inode and the mft record.
1649 *
1650 * This is modelled after fs/buffer.c::generic_commit_write(), which marks
1651 * buffers uptodate and dirty, sets the page uptodate if all buffers in the
1652 * page are uptodate, and updates i_size if the end of io is beyond i_size. In
1653 * that case, it also marks the inode dirty.
1654 *
1655 * If things have gone as outlined in
1656 * ntfs_prepare_pages_for_non_resident_write(), we do not need to do any page
1657 * content modifications here for non-resident attributes. For resident
1658 * attributes we need to do the uptodate bringing here which we combine with
1659 * the copying into the mft record which means we save one atomic kmap.
1660 *
1661 * Return 0 on success or -errno on error.
1662 */
1665 {
1667 loff_t i_size;
1676 u32 attr_len;
1693 /*
1694 * Attribute is resident, implying it is not compressed, encrypted, or
1695 * sparse.
1696 */
1699 else
1702 /* Map, pin, and lock the mft record. */
1709 }
1714 }
1721 }
1724 /* The total length of the attribute value. */
1734 /* Copy the received data from the page to the mft record. */
1736 /* Update the attribute length if necessary. */
1740 }
1741 /*
1742 * If the page is not uptodate, bring the out of bounds area(s)
1743 * uptodate by copying data from the mft record to the page.
1744 */
1750 /* Zero the region outside the end of the attribute value. */
1754 }
1756 /* Update initialized_size/i_size if necessary. */
1769 }
1770 /* Mark the mft record dirty, so it gets written back. */
1777 err_out:
1783 "dirty so the write will be retried "
1785 /*
1786 * Put the page on mapping->dirty_pages, but leave its
1787 * buffers' dirty state as-is.
1788 */
1798 }
1804 }
1806 /**
1807 * ntfs_file_buffered_write -
1808 *
1809 * Locking: The vfs is holding ->i_mutex on the inode.
1810 */
1814 {
1824 VCN last_vcn;
1825 LCN lcn;
1840 /*
1841 * If the attribute is not an index root and it is encrypted or
1842 * compressed, we cannot write to it yet. Note we need to check for
1843 * AT_INDEX_ALLOCATION since this is the type of both directory and
1844 * index inodes.
1845 */
1847 /* If file is encrypted, deny access, just like NT4. */
1849 /*
1850 * Reminder for later: Encrypted files are _always_
1851 * non-resident so that the content can always be
1852 * encrypted.
1853 */
1856 }
1858 /* Only unnamed $DATA attribute can be compressed. */
1861 /*
1862 * Reminder for later: If resident, the data is not
1863 * actually compressed. Only on the switch to non-
1864 * resident does compression kick in. This is in
1865 * contrast to encrypted files (see above).
1866 */
1870 }
1871 }
1872 /*
1873 * If a previous ntfs_truncate() failed, repeat it and abort if it
1874 * fails again.
1875 */
1884 "0x%lx, attribute type 0x%x, because "
1885 "ntfs_truncate() failed (error code "
1889 }
1890 }
1891 /* The first byte after the write. */
1893 /*
1894 * If the write goes beyond the allocated size, extend the allocation
1895 * to cover the whole of the write, rounded up to the nearest cluster.
1896 */
1901 /* Extend the allocation without changing the data size. */
1905 /* If the extension was partial truncate the write. */
1908 "attribute type 0x%x, because "
1909 "the allocation was only "
1915 }
1921 /* Perform a partial write if possible or fail. */
1924 "attribute type 0x%x, because "
1925 "extending the allocation "
1933 "inode 0x%lx, attribute type "
1934 "0x%x, because extending the "
1935 "allocation failed (error "
1940 }
1941 }
1942 }
1945 /*
1946 * If the write starts beyond the initialized size, extend it up to the
1947 * beginning of the write and initialize all non-sparse space between
1948 * the old initialized size and the new one. This automatically also
1949 * increments the vfs inode->i_size to keep it above or equal to the
1950 * initialized_size.
1951 */
1960 "0x%lx, attribute type 0x%x, because "
1961 "extending the initialized size "
1966 }
1967 }
1968 /*
1969 * Determine the number of pages per cluster for non-resident
1970 * attributes.
1971 */
1975 /* Finally, perform the actual write. */
1980 VCN vcn;
1993 /*
1994 * Get the lcn of the vcn the write is in. If
1995 * it is a hole, need to lock down all pages in
1996 * the cluster.
1997 */
2006 else
2008 "perform write to "
2009 "inode 0x%lx, "
2010 "attribute type 0x%x, "
2011 "because the attribute "
2016 }
2024 }
2025 }
2026 }
2029 /*
2030 * Bring in the user page(s) that we will copy from _first_.
2031 * Otherwise there is a nasty deadlock on copying from the same
2032 * page(s) as we are writing to, without it/them being marked
2033 * up-to-date. Note, at present there is nothing to stop the
2034 * pages being swapped out between us bringing them into memory
2035 * and doing the actual copying.
2036 */
2039 else
2041 /* Get and lock @do_pages starting at index @start_idx. */
2046 /*
2047 * For non-resident attributes, we need to fill any holes with
2048 * actual clusters and ensure all bufferes are mapped. We also
2049 * need to bring uptodate any buffers that are only partially
2050 * being written to.
2051 */
2056 loff_t i_size;
2062 /*
2063 * The write preparation may have instantiated
2064 * allocated space outside i_size. Trim this
2065 * off again. We can ignore any errors in this
2066 * case as we will just be waisting a bit of
2067 * allocated space, which is not a disaster.
2068 */
2073 }
2074 }
2083 bytes);
2086 bytes);
2093 }
2104 err_out:
2108 /* For now, when the user asks for O_SYNC, we actually give O_DSYNC. */
2114 }
2115 }
2121 }
2123 /**
2124 * ntfs_file_aio_write_nolock -
2125 */
2128 {
2132 loff_t pos;
2140 /*
2141 * If any segment has a negative length, or the cumulative
2142 * length ever wraps negative then return -EINVAL.
2143 */
2154 }
2157 /* We can write back this queue in page reclaim. */
2170 count);
2171 out:
2174 }
2176 /**
2177 * ntfs_file_aio_write -
2178 */
2181 {
2185 ssize_t ret;
2196 }
2198 }
2200 /**
2201 * ntfs_file_writev -
2202 *
2203 * Basically the same as generic_file_writev() except that it ends up calling
2204 * ntfs_file_aio_write_nolock() instead of __generic_file_aio_write_nolock().
2205 */
2208 {
2212 ssize_t ret;
2224 }
2226 }
2228 /**
2229 * ntfs_file_write - simple wrapper for ntfs_file_writev()
2230 */
2233 {
2238 }
2240 /**
2241 * ntfs_file_fsync - sync a file to disk
2242 * @filp: file to be synced
2243 * @dentry: dentry describing the file to sync
2244 * @datasync: if non-zero only flush user data and not metadata
2245 *
2246 * Data integrity sync of a file to disk. Used for fsync, fdatasync, and msync
2247 * system calls. This function is inspired by fs/buffer.c::file_fsync().
2248 *
2249 * If @datasync is false, write the mft record and all associated extent mft
2250 * records as well as the $DATA attribute and then sync the block device.
2251 *
2252 * If @datasync is true and the attribute is non-resident, we skip the writing
2253 * of the mft record and all associated extent mft records (this might still
2254 * happen due to the write_inode_now() call).
2255 *
2256 * Also, if @datasync is true, we do not wait on the inode to be written out
2257 * but we always wait on the page cache pages to be written out.
2258 *
2259 * Note: In the past @filp could be NULL so we ignore it as we don't need it
2260 * anyway.
2261 *
2262 * Locking: Caller must hold i_mutex on the inode.
2263 *
2264 * TODO: We should probably also write all attribute/index inodes associated
2265 * with this inode but since we have no simple way of getting to them we ignore
2266 * this problem for now.
2267 */
2270 {
2279 /*
2280 * NOTE: If we were to use mapping->private_list (see ext2 and
2281 * fs/buffer.c) for dirty blocks then we could optimize the below to be
2282 * sync_mapping_buffers(vi->i_mapping).
2283 */
2289 else
2293 }
2301 #ifdef NTFS_RW
2305 fs/ext2/file.c::
2306 ext2_release_file() for
2307 how to use this to discard
2308 preallocated space for
2309 write opened files. */
2312 i/o operations on a
2313 kiocb. */
2316 mounted filesystem. */
2320 the data source being on
2321 the ntfs partition. We do
2322 not need to care about the
2323 data destination. */
2325 the data destination being
2326 on the ntfs partition. We
2327 do not need to care about
2328 the data source. */
2329 };
2332 #ifdef NTFS_RW
2336 };