| blob | 7275338918132fe31eed51bddf2d48485d52c1b9 |
1 /*
2 * file.c - NTFS kernel file operations. Part of the Linux-NTFS project.
3 *
4 * Copyright (c) 2001-2005 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_sem 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 */
239 }
245 }
246 /*
247 * Update the initialized size in the ntfs inode. This is
248 * enough to make ntfs_writepage() work.
249 */
255 /* Set the page dirty so it gets written out. */
258 /*
259 * Play nice with the vm and the rest of the system. This is
260 * very much needed as we can potentially be modifying the
261 * initialised size from a very small value to a really huge
262 * value, e.g.
263 * f = open(somefile, O_TRUNC);
264 * truncate(f, 10GiB);
265 * seek(f, 10GiB);
266 * write(f, 1);
267 * And this would mean we would be marking dirty hundreds of
268 * thousands of pages or as in the above example more than
269 * two and a half million pages!
270 *
271 * TODO: For sparse pages could optimize this workload by using
272 * the FsMisc / MiscFs page bit as a "PageIsSparse" bit. This
273 * would be set in readpage for sparse pages and here we would
274 * not need to mark dirty any pages which have this bit set.
275 * The only caveat is that we have to clear the bit everywhere
276 * where we allocate any clusters that lie in the page or that
277 * contain the page.
278 *
279 * TODO: An even greater optimization would be for us to only
280 * call readpage() on pages which are not in sparse regions as
281 * determined from the runlist. This would greatly reduce the
282 * number of pages we read and make dirty in the case of sparse
283 * files.
284 */
291 /* Now bring in sync the initialized_size in the mft record. */
297 }
302 }
309 }
314 done:
324 init_err_out:
328 err_out:
335 }
337 /**
338 * ntfs_fault_in_pages_readable -
339 *
340 * Fault a number of userspace pages into pagetables.
341 *
342 * Unlike include/linux/pagemap.h::fault_in_pages_readable(), this one copes
343 * with more than two userspace pages as well as handling the single page case
344 * elegantly.
345 *
346 * If you find this difficult to understand, then think of the while loop being
347 * the following code, except that we do without the integer variable ret:
348 *
349 * do {
350 * ret = __get_user(c, uaddr);
351 * uaddr += PAGE_SIZE;
352 * } while (!ret && uaddr < end);
353 *
354 * Note, the final __get_user() may well run out-of-bounds of the user buffer,
355 * but _not_ out-of-bounds of the page the user buffer belongs to, and since
356 * this is only a read and not a write, and since it is still in the same page,
357 * it should not matter and this makes the code much simpler.
358 */
361 {
365 /* Set @end to the first byte outside the last page we care about. */
369 ;
370 }
372 /**
373 * ntfs_fault_in_pages_readable_iovec -
374 *
375 * Same as ntfs_fault_in_pages_readable() but operates on an array of iovecs.
376 */
379 {
390 iov++;
393 }
395 /**
396 * __ntfs_grab_cache_pages - obtain a number of locked pages
397 * @mapping: address space mapping from which to obtain page cache pages
398 * @index: starting index in @mapping at which to begin obtaining pages
399 * @nr_pages: number of page cache pages to obtain
400 * @pages: array of pages in which to return the obtained page cache pages
401 * @cached_page: allocated but as yet unused page
402 * @lru_pvec: lru-buffering pagevec of caller
403 *
404 * Obtain @nr_pages locked page cache pages from the mapping @maping and
405 * starting at index @index.
406 *
407 * If a page is newly created, increment its refcount and add it to the
408 * caller's lru-buffering pagevec @lru_pvec.
409 *
410 * This is the same as mm/filemap.c::__grab_cache_page(), except that @nr_pages
411 * are obtained at once instead of just one page and that 0 is returned on
412 * success and -errno on error.
413 *
414 * Note, the page locks are obtained in ascending page index order.
415 */
419 {
432 }
433 }
435 GFP_KERNEL);
440 }
446 }
447 index++;
448 nr++;
450 out:
452 err_out:
456 }
458 }
461 {
466 }
468 /**
469 * ntfs_prepare_pages_for_non_resident_write - prepare pages for receiving data
470 * @pages: array of destination pages
471 * @nr_pages: number of pages in @pages
472 * @pos: byte position in file at which the write begins
473 * @bytes: number of bytes to be written
474 *
475 * This is called for non-resident attributes from ntfs_file_buffered_write()
476 * with i_sem held on the inode (@pages[0]->mapping->host). There are
477 * @nr_pages pages in @pages which are locked but not kmap()ped. The source
478 * data has not yet been copied into the @pages.
479 *
480 * Need to fill any holes with actual clusters, allocate buffers if necessary,
481 * ensure all the buffers are mapped, and bring uptodate any buffers that are
482 * only partially being written to.
483 *
484 * If @nr_pages is greater than one, we are guaranteed that the cluster size is
485 * greater than PAGE_CACHE_SIZE, that all pages in @pages are entirely inside
486 * the same cluster and that they are the entirety of that cluster, and that
487 * the cluster is sparse, i.e. we need to allocate a cluster to fill the hole.
488 *
489 * i_size is not to be modified yet.
490 *
491 * Return 0 on success or -errno on error.
492 */
495 {
497 LCN lcn;
499 sector_t lcn_block;
537 /*
538 * create_empty_buffers() will create uptodate/dirty buffers if
539 * the page is uptodate/dirty.
540 */
545 }
557 /*
558 * Loop over each page and for each page over each buffer. Use goto to
559 * reduce indentation.
560 */
562 do_next_page:
567 VCN cdelta;
568 s64 bh_end;
571 /* Clear buffer_new on all buffers to reinitialise state. */
578 /*
579 * The buffer is already mapped. If it is uptodate,
580 * ignore it.
581 */
584 /*
585 * The buffer is not uptodate. If the page is uptodate
586 * set the buffer uptodate and otherwise ignore it.
587 */
591 }
592 /*
593 * Neither the page nor the buffer are uptodate. If
594 * the buffer is only partially being written to, we
595 * need to read it in before the write, i.e. now.
596 */
599 /*
600 * If the buffer is fully or partially within
601 * the initialized size, do an actual read.
602 * Otherwise, simply zero the buffer.
603 */
613 blocksize);
617 }
618 }
620 }
621 /* Unmapped buffer. Need to map it. */
623 /*
624 * If the current buffer is in the same clusters as the map
625 * cache, there is no need to check the runlist again. The
626 * map cache is made up of @vcn, which is the first cached file
627 * cluster, @vcn_len which is the number of cached file
628 * clusters, @lcn is the device cluster corresponding to @vcn,
629 * and @lcn_block is the block number corresponding to @lcn.
630 */
633 map_buffer_cached:
637 blocksize_bits)) +
640 /*
641 * If the page is uptodate so is the buffer. If the
642 * buffer is fully outside the write, we ignore it if
643 * it was already allocated and we mark it dirty so it
644 * gets written out if we allocated it. On the other
645 * hand, if we allocated the buffer but we are not
646 * marking it dirty we set buffer_new so we can do
647 * error recovery.
648 */
653 /* We allocated the buffer. */
658 else
660 }
662 }
663 /* Page is _not_ uptodate. */
665 /*
666 * Buffer was already allocated. If it is not
667 * uptodate and is only partially being written
668 * to, we need to read it in before the write,
669 * i.e. now.
670 */
675 /*
676 * If the buffer is fully or partially
677 * within the initialized size, do an
678 * actual read. Otherwise, simply zero
679 * the buffer.
680 */
682 flags);
685 flags);
691 KM_USER0);
697 }
698 }
700 }
701 /* We allocated the buffer. */
703 /*
704 * If the buffer is fully outside the write, zero it,
705 * set it uptodate, and mark it dirty so it gets
706 * written out. If it is partially being written to,
707 * zero region surrounding the write but leave it to
708 * commit write to do anything else. Finally, if the
709 * buffer is fully being overwritten, do nothing.
710 */
715 blocksize);
719 }
722 }
733 }
737 }
740 }
742 }
743 /*
744 * Slow path: this is the first buffer in the cluster. If it
745 * is outside allocated size and is not uptodate, zero it and
746 * set it uptodate.
747 */
761 }
763 }
767 retry_remap:
769 }
771 /* Seek to element containing target cluster. */
773 rl++;
776 /*
777 * Successful remap, setup the map cache and
778 * use that to deal with the buffer.
779 */
784 blocksize_bits);
786 /*
787 * If the number of remaining clusters touched
788 * by the write is smaller or equal to the
789 * number of cached clusters, unlock the
790 * runlist as the map cache will be used from
791 * now on.
792 */
800 }
802 }
805 /*
806 * If it is not a hole and not out of bounds, the runlist is
807 * probably unmapped so try to map it now.
808 */
811 /* Attempt to map runlist. */
813 /*
814 * We need the runlist locked for
815 * writing, so if it is locked for
816 * reading relock it now and retry in
817 * case it changed whilst we dropped
818 * the lock.
819 */
824 }
826 NULL);
830 }
831 /*
832 * If @vcn is out of bounds, pretend @lcn is
833 * LCN_ENOENT. As long as the buffer is out
834 * of bounds this will work fine.
835 */
840 }
843 /* Failed to map the buffer, even after retrying. */
846 "attribute type 0x%x, vcn 0x%llx, "
847 "vcn offset 0x%x, because its "
848 "location on disk could not be "
855 err);
857 }
858 rl_not_mapped_enoent:
859 /*
860 * The buffer is in a hole or out of bounds. We need to fill
861 * the hole, unless the buffer is in a cluster which is not
862 * touched by the write, in which case we just leave the buffer
863 * unmapped. This can only happen when the cluster size is
864 * less than the page cache size.
865 */
871 /*
872 * If the buffer is uptodate we skip it. If it
873 * is not but the page is uptodate, we can set
874 * the buffer uptodate. If the page is not
875 * uptodate, we can clear the buffer and set it
876 * uptodate. Whether this is worthwhile is
877 * debatable and this could be removed.
878 */
885 blocksize);
889 }
891 }
892 }
893 /*
894 * Out of bounds buffer is invalid if it was not really out of
895 * bounds.
896 */
898 /*
899 * We need the runlist locked for writing, so if it is locked
900 * for reading relock it now and retry in case it changed
901 * whilst we dropped the lock.
902 */
909 }
910 /* Find the previous last allocated cluster. */
918 }
919 }
921 FALSE);
925 err);
927 }
936 "allocated cluster in error "
937 "code path. Run chkdsk to "
940 }
943 }
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 "
1214 /*
1215 * Deallocate the on-disk cluster we allocated but only
1216 * if we succeeded in punching its vcn out of the
1217 * runlist.
1218 */
1222 "allocated cluster in error "
1223 "code path. Run chkdsk to "
1226 }
1228 }
1229 }
1230 /*
1231 * Resize the attribute record to its old size and rebuild the mapping
1232 * pairs array. Note, we only can do this if the runlist has been
1233 * restored to its old state which also implies that the mapped
1234 * attribute extent is not switched.
1235 */
1239 "record in error code path. Run "
1252 "mapping pairs array in error "
1253 "code path. Run chkdsk to "
1258 }
1261 }
1262 }
1263 /* Release the mft record and the attribute. */
1267 }
1268 /* Release the runlist lock. */
1273 /*
1274 * Zero out any newly allocated blocks to avoid exposing stale data.
1275 * If BH_New is set, we know that the block was newly allocated above
1276 * and that it has not been fully zeroed and marked dirty yet.
1277 */
1298 blocksize);
1302 }
1303 }
1309 }
1311 /*
1312 * Copy as much as we can into the pages and return the number of bytes which
1313 * were sucessfully copied. If a fault is encountered then clear the pages
1314 * out to (ofs + bytes) and return the number of bytes which were copied.
1315 */
1319 {
1334 /* Do it the slow way. */
1340 }
1348 out:
1350 err_out:
1352 /* Zero the rest of the target like __copy_from_user(). */
1363 }
1365 }
1369 {
1385 /*
1386 * Zero the rest of the target like __copy_from_user().
1387 */
1391 }
1394 iov++;
1396 }
1398 }
1402 {
1415 iov++;
1417 }
1418 }
1421 }
1423 /*
1424 * This has the same side-effects and return value as ntfs_copy_from_user().
1425 * The difference is that on a fault we need to memset the remainder of the
1426 * pages (out to offset + bytes), to emulate ntfs_copy_from_user()'s
1427 * single-segment behaviour.
1428 *
1429 * We call the same helper (__ntfs_copy_from_user_iovec()) both when atomic and
1430 * when not atomic. This is ok because __ntfs_copy_from_user_iovec() calls
1431 * __copy_from_user_inatomic() and it is ok to call this when non-atomic. In
1432 * fact, the only difference between __copy_from_user_inatomic() and
1433 * __copy_from_user() is that the latter calls might_sleep(). And on many
1434 * architectures __copy_from_user_inatomic() is just defined to
1435 * __copy_from_user() so it makes no difference at all on those architectures.
1436 */
1440 {
1454 /* Do it the slow way. */
1461 }
1469 out:
1471 err_out:
1473 /* Zero the rest of the target like __copy_from_user(). */
1484 }
1486 }
1490 {
1493 /*
1494 * Warning: Do not do the decrement at the same time as the
1495 * call because flush_dcache_page() is a NULL macro on i386
1496 * and hence the decrement never happens.
1497 */
1500 }
1502 /**
1503 * ntfs_commit_pages_after_non_resident_write - commit the received data
1504 * @pages: array of destination pages
1505 * @nr_pages: number of pages in @pages
1506 * @pos: byte position in file at which the write begins
1507 * @bytes: number of bytes to be written
1508 *
1509 * See description of ntfs_commit_pages_after_write(), below.
1510 */
1514 {
1532 s64 bh_pos;
1534 BOOL partial;
1541 s64 bh_end;
1550 }
1552 /*
1553 * If all buffers are now uptodate but the page is not, set the
1554 * page uptodate.
1555 */
1559 /*
1560 * Finally, if we do not need to update initialized_size or i_size we
1561 * are finished.
1562 */
1569 }
1570 /*
1571 * Update initialized_size/i_size as appropriate, both in the inode and
1572 * the mft record.
1573 */
1576 else
1578 /* Map, pin, and lock the mft record. */
1585 }
1591 }
1598 }
1609 }
1611 /* Mark the mft record dirty, so it gets written back. */
1618 err_out:
1629 }
1631 }
1633 /**
1634 * ntfs_commit_pages_after_write - commit the received data
1635 * @pages: array of destination pages
1636 * @nr_pages: number of pages in @pages
1637 * @pos: byte position in file at which the write begins
1638 * @bytes: number of bytes to be written
1639 *
1640 * This is called from ntfs_file_buffered_write() with i_sem held on the inode
1641 * (@pages[0]->mapping->host). There are @nr_pages pages in @pages which are
1642 * locked but not kmap()ped. The source data has already been copied into the
1643 * @page. ntfs_prepare_pages_for_non_resident_write() has been called before
1644 * the data was copied (for non-resident attributes only) and it returned
1645 * success.
1646 *
1647 * Need to set uptodate and mark dirty all buffers within the boundary of the
1648 * write. If all buffers in a page are uptodate we set the page uptodate, too.
1649 *
1650 * Setting the buffers dirty ensures that they get written out later when
1651 * ntfs_writepage() is invoked by the VM.
1652 *
1653 * Finally, we need to update i_size and initialized_size as appropriate both
1654 * in the inode and the mft record.
1655 *
1656 * This is modelled after fs/buffer.c::generic_commit_write(), which marks
1657 * buffers uptodate and dirty, sets the page uptodate if all buffers in the
1658 * page are uptodate, and updates i_size if the end of io is beyond i_size. In
1659 * that case, it also marks the inode dirty.
1660 *
1661 * If things have gone as outlined in
1662 * ntfs_prepare_pages_for_non_resident_write(), we do not need to do any page
1663 * content modifications here for non-resident attributes. For resident
1664 * attributes we need to do the uptodate bringing here which we combine with
1665 * the copying into the mft record which means we save one atomic kmap.
1666 *
1667 * Return 0 on success or -errno on error.
1668 */
1671 {
1673 loff_t i_size;
1682 u32 attr_len;
1699 /*
1700 * Attribute is resident, implying it is not compressed, encrypted, or
1701 * sparse.
1702 */
1705 else
1708 /* Map, pin, and lock the mft record. */
1715 }
1720 }
1727 }
1730 /* The total length of the attribute value. */
1740 /* Copy the received data from the page to the mft record. */
1742 /* Update the attribute length if necessary. */
1746 }
1747 /*
1748 * If the page is not uptodate, bring the out of bounds area(s)
1749 * uptodate by copying data from the mft record to the page.
1750 */
1756 /* Zero the region outside the end of the attribute value. */
1760 }
1762 /* Update initialized_size/i_size if necessary. */
1775 }
1776 /* Mark the mft record dirty, so it gets written back. */
1783 err_out:
1789 "dirty so the write will be retried "
1791 /*
1792 * Put the page on mapping->dirty_pages, but leave its
1793 * buffers' dirty state as-is.
1794 */
1806 }
1812 }
1814 /**
1815 * ntfs_file_buffered_write -
1816 *
1817 * Locking: The vfs is holding ->i_sem on the inode.
1818 */
1822 {
1832 VCN last_vcn;
1833 LCN lcn;
1848 /*
1849 * If the attribute is not an index root and it is encrypted or
1850 * compressed, we cannot write to it yet. Note we need to check for
1851 * AT_INDEX_ALLOCATION since this is the type of both directory and
1852 * index inodes.
1853 */
1855 /* If file is encrypted, deny access, just like NT4. */
1857 /*
1858 * Reminder for later: Encrypted files are _always_
1859 * non-resident so that the content can always be
1860 * encrypted.
1861 */
1864 }
1866 /* Only unnamed $DATA attribute can be compressed. */
1869 /*
1870 * Reminder for later: If resident, the data is not
1871 * actually compressed. Only on the switch to non-
1872 * resident does compression kick in. This is in
1873 * contrast to encrypted files (see above).
1874 */
1878 }
1879 }
1880 /*
1881 * If a previous ntfs_truncate() failed, repeat it and abort if it
1882 * fails again.
1883 */
1892 "0x%lx, attribute type 0x%x, because "
1893 "ntfs_truncate() failed (error code "
1897 }
1898 }
1899 /* The first byte after the write. */
1901 /*
1902 * If the write goes beyond the allocated size, extend the allocation
1903 * to cover the whole of the write, rounded up to the nearest cluster.
1904 */
1909 /* Extend the allocation without changing the data size. */
1913 /* If the extension was partial truncate the write. */
1916 "attribute type 0x%x, because "
1917 "the allocation was only "
1923 }
1929 /* Perform a partial write if possible or fail. */
1932 "attribute type 0x%x, because "
1933 "extending the allocation "
1941 "inode 0x%lx, attribute type "
1942 "0x%x, because extending the "
1943 "allocation failed (error "
1948 }
1949 }
1950 }
1953 /*
1954 * If the write starts beyond the initialized size, extend it up to the
1955 * beginning of the write and initialize all non-sparse space between
1956 * the old initialized size and the new one. This automatically also
1957 * increments the vfs inode->i_size to keep it above or equal to the
1958 * initialized_size.
1959 */
1968 "0x%lx, attribute type 0x%x, because "
1969 "extending the initialized size "
1974 }
1975 }
1976 /*
1977 * Determine the number of pages per cluster for non-resident
1978 * attributes.
1979 */
1983 /* Finally, perform the actual write. */
1988 VCN vcn;
2001 /*
2002 * Get the lcn of the vcn the write is in. If
2003 * it is a hole, need to lock down all pages in
2004 * the cluster.
2005 */
2014 else
2016 "perform write to "
2017 "inode 0x%lx, "
2018 "attribute type 0x%x, "
2019 "because the attribute "
2024 }
2032 }
2033 }
2034 }
2037 /*
2038 * Bring in the user page(s) that we will copy from _first_.
2039 * Otherwise there is a nasty deadlock on copying from the same
2040 * page(s) as we are writing to, without it/them being marked
2041 * up-to-date. Note, at present there is nothing to stop the
2042 * pages being swapped out between us bringing them into memory
2043 * and doing the actual copying.
2044 */
2047 else
2049 /* Get and lock @do_pages starting at index @start_idx. */
2054 /*
2055 * For non-resident attributes, we need to fill any holes with
2056 * actual clusters and ensure all bufferes are mapped. We also
2057 * need to bring uptodate any buffers that are only partially
2058 * being written to.
2059 */
2064 loff_t i_size;
2070 /*
2071 * The write preparation may have instantiated
2072 * allocated space outside i_size. Trim this
2073 * off again. We can ignore any errors in this
2074 * case as we will just be waisting a bit of
2075 * allocated space, which is not a disaster.
2076 */
2081 }
2082 }
2091 bytes);
2094 bytes);
2101 }
2112 err_out:
2116 /* For now, when the user asks for O_SYNC, we actually give O_DSYNC. */
2122 }
2123 }
2129 }
2131 /**
2132 * ntfs_file_aio_write_nolock -
2133 */
2136 {
2140 loff_t pos;
2148 /*
2149 * If any segment has a negative length, or the cumulative
2150 * length ever wraps negative then return -EINVAL.
2151 */
2162 }
2165 /* We can write back this queue in page reclaim. */
2178 count);
2179 out:
2182 }
2184 /**
2185 * ntfs_file_aio_write -
2186 */
2189 {
2193 ssize_t ret;
2206 }
2208 }
2210 /**
2211 * ntfs_file_writev -
2212 *
2213 * Basically the same as generic_file_writev() except that it ends up calling
2214 * ntfs_file_aio_write_nolock() instead of __generic_file_aio_write_nolock().
2215 */
2218 {
2222 ssize_t ret;
2234 }
2236 }
2238 /**
2239 * ntfs_file_write - simple wrapper for ntfs_file_writev()
2240 */
2243 {
2248 }
2250 /**
2251 * ntfs_file_fsync - sync a file to disk
2252 * @filp: file to be synced
2253 * @dentry: dentry describing the file to sync
2254 * @datasync: if non-zero only flush user data and not metadata
2255 *
2256 * Data integrity sync of a file to disk. Used for fsync, fdatasync, and msync
2257 * system calls. This function is inspired by fs/buffer.c::file_fsync().
2258 *
2259 * If @datasync is false, write the mft record and all associated extent mft
2260 * records as well as the $DATA attribute and then sync the block device.
2261 *
2262 * If @datasync is true and the attribute is non-resident, we skip the writing
2263 * of the mft record and all associated extent mft records (this might still
2264 * happen due to the write_inode_now() call).
2265 *
2266 * Also, if @datasync is true, we do not wait on the inode to be written out
2267 * but we always wait on the page cache pages to be written out.
2268 *
2269 * Note: In the past @filp could be NULL so we ignore it as we don't need it
2270 * anyway.
2271 *
2272 * Locking: Caller must hold i_sem on the inode.
2273 *
2274 * TODO: We should probably also write all attribute/index inodes associated
2275 * with this inode but since we have no simple way of getting to them we ignore
2276 * this problem for now.
2277 */
2280 {
2289 /*
2290 * NOTE: If we were to use mapping->private_list (see ext2 and
2291 * fs/buffer.c) for dirty blocks then we could optimize the below to be
2292 * sync_mapping_buffers(vi->i_mapping).
2293 */
2299 else
2303 }
2312 #ifdef NTFS_RW
2317 fs/ext2/file.c::
2318 ext2_release_file() for
2319 how to use this to discard
2320 preallocated space for
2321 write opened files. */
2324 i/o operations on a
2325 kiocb. */
2328 mounted filesystem. */
2332 the data source being on
2333 the ntfs partition. We do
2334 not need to care about the
2335 data destination. */
2337 the data destination being
2338 on the ntfs partition. We
2339 do not need to care about
2340 the data source. */
2341 };
2344 #ifdef NTFS_RW
2348 };