2 * aops.c - NTFS kernel address space operations and page cache handling.
3 * Part of the Linux-NTFS project.
5 * Copyright (c) 2001-2005 Anton Altaparmakov
6 * Copyright (c) 2002 Richard Russon
8 * This program/include file is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as published
10 * by the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program/include file is distributed in the hope that it will be
14 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program (in the main directory of the Linux-NTFS
20 * distribution in the file COPYING); if not, write to the Free Software
21 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/errno.h>
26 #include <linux/pagemap.h>
27 #include <linux/swap.h>
28 #include <linux/buffer_head.h>
29 #include <linux/writeback.h>
41 * ntfs_end_buffer_async_read - async io completion for reading attributes
42 * @bh: buffer head on which io is completed
43 * @uptodate: whether @bh is now uptodate or not
45 * Asynchronous I/O completion handler for reading pages belonging to the
46 * attribute address space of an inode. The inodes can either be files or
47 * directories or they can be fake inodes describing some attribute.
49 * If NInoMstProtected(), perform the post read mst fixups when all IO on the
50 * page has been completed and mark the page uptodate or set the error bit on
51 * the page. To determine the size of the records that need fixing up, we
52 * cheat a little bit by setting the index_block_size in ntfs_inode to the ntfs
53 * record size, and index_block_size_bits, to the log(base 2) of the ntfs
56 static void ntfs_end_buffer_async_read(struct buffer_head
*bh
, int uptodate
)
58 static DEFINE_SPINLOCK(page_uptodate_lock
);
60 struct buffer_head
*tmp
;
63 int page_uptodate
= 1;
66 ni
= NTFS_I(page
->mapping
->host
);
68 if (likely(uptodate
)) {
69 s64 file_ofs
, initialized_size
;
71 set_buffer_uptodate(bh
);
73 file_ofs
= ((s64
)page
->index
<< PAGE_CACHE_SHIFT
) +
75 read_lock_irqsave(&ni
->size_lock
, flags
);
76 initialized_size
= ni
->initialized_size
;
77 read_unlock_irqrestore(&ni
->size_lock
, flags
);
78 /* Check for the current buffer head overflowing. */
79 if (file_ofs
+ bh
->b_size
> initialized_size
) {
83 if (file_ofs
< initialized_size
)
84 ofs
= initialized_size
- file_ofs
;
85 addr
= kmap_atomic(page
, KM_BIO_SRC_IRQ
);
86 memset(addr
+ bh_offset(bh
) + ofs
, 0, bh
->b_size
- ofs
);
87 flush_dcache_page(page
);
88 kunmap_atomic(addr
, KM_BIO_SRC_IRQ
);
91 clear_buffer_uptodate(bh
);
92 ntfs_error(ni
->vol
->sb
, "Buffer I/O error, logical block %llu.",
93 (unsigned long long)bh
->b_blocknr
);
96 spin_lock_irqsave(&page_uptodate_lock
, flags
);
97 clear_buffer_async_read(bh
);
101 if (!buffer_uptodate(tmp
))
103 if (buffer_async_read(tmp
)) {
104 if (likely(buffer_locked(tmp
)))
106 /* Async buffers must be locked. */
109 tmp
= tmp
->b_this_page
;
111 spin_unlock_irqrestore(&page_uptodate_lock
, flags
);
113 * If none of the buffers had errors then we can set the page uptodate,
114 * but we first have to perform the post read mst fixups, if the
115 * attribute is mst protected, i.e. if NInoMstProteced(ni) is true.
116 * Note we ignore fixup errors as those are detected when
117 * map_mft_record() is called which gives us per record granularity
118 * rather than per page granularity.
120 if (!NInoMstProtected(ni
)) {
121 if (likely(page_uptodate
&& !PageError(page
)))
122 SetPageUptodate(page
);
125 unsigned int i
, recs
;
128 rec_size
= ni
->itype
.index
.block_size
;
129 recs
= PAGE_CACHE_SIZE
/ rec_size
;
130 /* Should have been verified before we got here... */
132 addr
= kmap_atomic(page
, KM_BIO_SRC_IRQ
);
133 for (i
= 0; i
< recs
; i
++)
134 post_read_mst_fixup((NTFS_RECORD
*)(addr
+
135 i
* rec_size
), rec_size
);
136 flush_dcache_page(page
);
137 kunmap_atomic(addr
, KM_BIO_SRC_IRQ
);
138 if (likely(page_uptodate
&& !PageError(page
)))
139 SetPageUptodate(page
);
144 spin_unlock_irqrestore(&page_uptodate_lock
, flags
);
149 * ntfs_read_block - fill a @page of an address space with data
150 * @page: page cache page to fill with data
152 * Fill the page @page of the address space belonging to the @page->host inode.
153 * We read each buffer asynchronously and when all buffers are read in, our io
154 * completion handler ntfs_end_buffer_read_async(), if required, automatically
155 * applies the mst fixups to the page before finally marking it uptodate and
158 * We only enforce allocated_size limit because i_size is checked for in
159 * generic_file_read().
161 * Return 0 on success and -errno on error.
163 * Contains an adapted version of fs/buffer.c::block_read_full_page().
165 static int ntfs_read_block(struct page
*page
)
172 struct buffer_head
*bh
, *head
, *arr
[MAX_BUF_PER_PAGE
];
173 sector_t iblock
, lblock
, zblock
;
175 unsigned int blocksize
, vcn_ofs
;
177 unsigned char blocksize_bits
;
179 ni
= NTFS_I(page
->mapping
->host
);
182 /* $MFT/$DATA must have its complete runlist in memory at all times. */
183 BUG_ON(!ni
->runlist
.rl
&& !ni
->mft_no
&& !NInoAttr(ni
));
185 blocksize_bits
= VFS_I(ni
)->i_blkbits
;
186 blocksize
= 1 << blocksize_bits
;
188 if (!page_has_buffers(page
))
189 create_empty_buffers(page
, blocksize
, 0);
190 bh
= head
= page_buffers(page
);
196 iblock
= (s64
)page
->index
<< (PAGE_CACHE_SHIFT
- blocksize_bits
);
197 read_lock_irqsave(&ni
->size_lock
, flags
);
198 lblock
= (ni
->allocated_size
+ blocksize
- 1) >> blocksize_bits
;
199 zblock
= (ni
->initialized_size
+ blocksize
- 1) >> blocksize_bits
;
200 read_unlock_irqrestore(&ni
->size_lock
, flags
);
202 /* Loop through all the buffers in the page. */
208 if (unlikely(buffer_uptodate(bh
)))
210 if (unlikely(buffer_mapped(bh
))) {
214 bh
->b_bdev
= vol
->sb
->s_bdev
;
215 /* Is the block within the allowed limits? */
216 if (iblock
< lblock
) {
217 BOOL is_retry
= FALSE
;
219 /* Convert iblock into corresponding vcn and offset. */
220 vcn
= (VCN
)iblock
<< blocksize_bits
>>
221 vol
->cluster_size_bits
;
222 vcn_ofs
= ((VCN
)iblock
<< blocksize_bits
) &
223 vol
->cluster_size_mask
;
226 down_read(&ni
->runlist
.lock
);
229 if (likely(rl
!= NULL
)) {
230 /* Seek to element containing target vcn. */
231 while (rl
->length
&& rl
[1].vcn
<= vcn
)
233 lcn
= ntfs_rl_vcn_to_lcn(rl
, vcn
);
235 lcn
= LCN_RL_NOT_MAPPED
;
236 /* Successful remap. */
238 /* Setup buffer head to correct block. */
239 bh
->b_blocknr
= ((lcn
<< vol
->cluster_size_bits
)
240 + vcn_ofs
) >> blocksize_bits
;
241 set_buffer_mapped(bh
);
242 /* Only read initialized data blocks. */
243 if (iblock
< zblock
) {
247 /* Fully non-initialized data block, zero it. */
250 /* It is a hole, need to zero it. */
253 /* If first try and runlist unmapped, map and retry. */
254 if (!is_retry
&& lcn
== LCN_RL_NOT_MAPPED
) {
258 * Attempt to map runlist, dropping lock for
261 up_read(&ni
->runlist
.lock
);
262 err
= ntfs_map_runlist(ni
, vcn
);
264 goto lock_retry_remap
;
268 up_read(&ni
->runlist
.lock
);
269 /* Hard error, zero out region. */
272 ntfs_error(vol
->sb
, "Failed to read from inode 0x%lx, "
273 "attribute type 0x%x, vcn 0x%llx, "
274 "offset 0x%x because its location on "
275 "disk could not be determined%s "
276 "(error code %lli).", ni
->mft_no
,
277 ni
->type
, (unsigned long long)vcn
,
278 vcn_ofs
, is_retry
? " even after "
279 "retrying" : "", (long long)lcn
);
282 * Either iblock was outside lblock limits or
283 * ntfs_rl_vcn_to_lcn() returned error. Just zero that portion
284 * of the page and set the buffer uptodate.
287 bh
->b_blocknr
= -1UL;
288 clear_buffer_mapped(bh
);
290 kaddr
= kmap_atomic(page
, KM_USER0
);
291 memset(kaddr
+ i
* blocksize
, 0, blocksize
);
292 flush_dcache_page(page
);
293 kunmap_atomic(kaddr
, KM_USER0
);
294 set_buffer_uptodate(bh
);
295 } while (i
++, iblock
++, (bh
= bh
->b_this_page
) != head
);
297 /* Release the lock if we took it. */
299 up_read(&ni
->runlist
.lock
);
301 /* Check we have at least one buffer ready for i/o. */
303 struct buffer_head
*tbh
;
305 /* Lock the buffers. */
306 for (i
= 0; i
< nr
; i
++) {
309 tbh
->b_end_io
= ntfs_end_buffer_async_read
;
310 set_buffer_async_read(tbh
);
312 /* Finally, start i/o on the buffers. */
313 for (i
= 0; i
< nr
; i
++) {
315 if (likely(!buffer_uptodate(tbh
)))
316 submit_bh(READ
, tbh
);
318 ntfs_end_buffer_async_read(tbh
, 1);
322 /* No i/o was scheduled on any of the buffers. */
323 if (likely(!PageError(page
)))
324 SetPageUptodate(page
);
325 else /* Signal synchronous i/o error. */
332 * ntfs_readpage - fill a @page of a @file with data from the device
333 * @file: open file to which the page @page belongs or NULL
334 * @page: page cache page to fill with data
336 * For non-resident attributes, ntfs_readpage() fills the @page of the open
337 * file @file by calling the ntfs version of the generic block_read_full_page()
338 * function, ntfs_read_block(), which in turn creates and reads in the buffers
339 * associated with the page asynchronously.
341 * For resident attributes, OTOH, ntfs_readpage() fills @page by copying the
342 * data from the mft record (which at this stage is most likely in memory) and
343 * fills the remainder with zeroes. Thus, in this case, I/O is synchronous, as
344 * even if the mft record is not cached at this point in time, we need to wait
345 * for it to be read in before we can do the copy.
347 * Return 0 on success and -errno on error.
349 static int ntfs_readpage(struct file
*file
, struct page
*page
)
351 ntfs_inode
*ni
, *base_ni
;
353 ntfs_attr_search_ctx
*ctx
;
360 BUG_ON(!PageLocked(page
));
362 * This can potentially happen because we clear PageUptodate() during
363 * ntfs_writepage() of MstProtected() attributes.
365 if (PageUptodate(page
)) {
369 ni
= NTFS_I(page
->mapping
->host
);
371 /* NInoNonResident() == NInoIndexAllocPresent() */
372 if (NInoNonResident(ni
)) {
374 * Only unnamed $DATA attributes can be compressed or
377 if (ni
->type
== AT_DATA
&& !ni
->name_len
) {
378 /* If file is encrypted, deny access, just like NT4. */
379 if (NInoEncrypted(ni
)) {
383 /* Compressed data streams are handled in compress.c. */
384 if (NInoCompressed(ni
))
385 return ntfs_read_compressed_block(page
);
387 /* Normal data stream. */
388 return ntfs_read_block(page
);
391 * Attribute is resident, implying it is not compressed or encrypted.
392 * This also means the attribute is smaller than an mft record and
393 * hence smaller than a page, so can simply zero out any pages with
396 if (unlikely(page
->index
> 0)) {
397 kaddr
= kmap_atomic(page
, KM_USER0
);
398 memset(kaddr
, 0, PAGE_CACHE_SIZE
);
399 flush_dcache_page(page
);
400 kunmap_atomic(kaddr
, KM_USER0
);
406 base_ni
= ni
->ext
.base_ntfs_ino
;
407 /* Map, pin, and lock the mft record. */
408 mrec
= map_mft_record(base_ni
);
414 * If a parallel write made the attribute non-resident, drop the mft
415 * record and retry the readpage.
417 if (unlikely(NInoNonResident(ni
))) {
418 unmap_mft_record(base_ni
);
421 ctx
= ntfs_attr_get_search_ctx(base_ni
, mrec
);
422 if (unlikely(!ctx
)) {
426 err
= ntfs_attr_lookup(ni
->type
, ni
->name
, ni
->name_len
,
427 CASE_SENSITIVE
, 0, NULL
, 0, ctx
);
429 goto put_unm_err_out
;
430 attr_len
= le32_to_cpu(ctx
->attr
->data
.resident
.value_length
);
431 read_lock_irqsave(&ni
->size_lock
, flags
);
432 if (unlikely(attr_len
> ni
->initialized_size
))
433 attr_len
= ni
->initialized_size
;
434 read_unlock_irqrestore(&ni
->size_lock
, flags
);
435 kaddr
= kmap_atomic(page
, KM_USER0
);
436 /* Copy the data to the page. */
437 memcpy(kaddr
, (u8
*)ctx
->attr
+
438 le16_to_cpu(ctx
->attr
->data
.resident
.value_offset
),
440 /* Zero the remainder of the page. */
441 memset(kaddr
+ attr_len
, 0, PAGE_CACHE_SIZE
- attr_len
);
442 flush_dcache_page(page
);
443 kunmap_atomic(kaddr
, KM_USER0
);
445 ntfs_attr_put_search_ctx(ctx
);
447 unmap_mft_record(base_ni
);
449 SetPageUptodate(page
);
458 * ntfs_write_block - write a @page to the backing store
459 * @page: page cache page to write out
460 * @wbc: writeback control structure
462 * This function is for writing pages belonging to non-resident, non-mst
463 * protected attributes to their backing store.
465 * For a page with buffers, map and write the dirty buffers asynchronously
466 * under page writeback. For a page without buffers, create buffers for the
467 * page, then proceed as above.
469 * If a page doesn't have buffers the page dirty state is definitive. If a page
470 * does have buffers, the page dirty state is just a hint, and the buffer dirty
471 * state is definitive. (A hint which has rules: dirty buffers against a clean
472 * page is illegal. Other combinations are legal and need to be handled. In
473 * particular a dirty page containing clean buffers for example.)
475 * Return 0 on success and -errno on error.
477 * Based on ntfs_read_block() and __block_write_full_page().
479 static int ntfs_write_block(struct page
*page
, struct writeback_control
*wbc
)
483 s64 initialized_size
;
485 sector_t block
, dblock
, iblock
;
490 struct buffer_head
*bh
, *head
;
492 unsigned int blocksize
, vcn_ofs
;
494 BOOL need_end_writeback
;
495 unsigned char blocksize_bits
;
497 vi
= page
->mapping
->host
;
501 ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "
502 "0x%lx.", ni
->mft_no
, ni
->type
, page
->index
);
504 BUG_ON(!NInoNonResident(ni
));
505 BUG_ON(NInoMstProtected(ni
));
507 blocksize_bits
= vi
->i_blkbits
;
508 blocksize
= 1 << blocksize_bits
;
510 if (!page_has_buffers(page
)) {
511 BUG_ON(!PageUptodate(page
));
512 create_empty_buffers(page
, blocksize
,
513 (1 << BH_Uptodate
) | (1 << BH_Dirty
));
515 bh
= head
= page_buffers(page
);
517 ntfs_warning(vol
->sb
, "Error allocating page buffers. "
518 "Redirtying page so we try again later.");
520 * Put the page back on mapping->dirty_pages, but leave its
521 * buffer's dirty state as-is.
523 redirty_page_for_writepage(wbc
, page
);
528 /* NOTE: Different naming scheme to ntfs_read_block()! */
530 /* The first block in the page. */
531 block
= (s64
)page
->index
<< (PAGE_CACHE_SHIFT
- blocksize_bits
);
533 read_lock_irqsave(&ni
->size_lock
, flags
);
534 i_size
= i_size_read(vi
);
535 initialized_size
= ni
->initialized_size
;
536 read_unlock_irqrestore(&ni
->size_lock
, flags
);
538 /* The first out of bounds block for the data size. */
539 dblock
= (i_size
+ blocksize
- 1) >> blocksize_bits
;
541 /* The last (fully or partially) initialized block. */
542 iblock
= initialized_size
>> blocksize_bits
;
545 * Be very careful. We have no exclusion from __set_page_dirty_buffers
546 * here, and the (potentially unmapped) buffers may become dirty at
547 * any time. If a buffer becomes dirty here after we've inspected it
548 * then we just miss that fact, and the page stays dirty.
550 * Buffers outside i_size may be dirtied by __set_page_dirty_buffers;
551 * handle that here by just cleaning them.
555 * Loop through all the buffers in the page, mapping all the dirty
556 * buffers to disk addresses and handling any aliases from the
557 * underlying block device's mapping.
562 BOOL is_retry
= FALSE
;
564 if (unlikely(block
>= dblock
)) {
566 * Mapped buffers outside i_size will occur, because
567 * this page can be outside i_size when there is a
568 * truncate in progress. The contents of such buffers
569 * were zeroed by ntfs_writepage().
571 * FIXME: What about the small race window where
572 * ntfs_writepage() has not done any clearing because
573 * the page was within i_size but before we get here,
574 * vmtruncate() modifies i_size?
576 clear_buffer_dirty(bh
);
577 set_buffer_uptodate(bh
);
581 /* Clean buffers are not written out, so no need to map them. */
582 if (!buffer_dirty(bh
))
585 /* Make sure we have enough initialized size. */
586 if (unlikely((block
>= iblock
) &&
587 (initialized_size
< i_size
))) {
589 * If this page is fully outside initialized size, zero
590 * out all pages between the current initialized size
591 * and the current page. Just use ntfs_readpage() to do
592 * the zeroing transparently.
594 if (block
> iblock
) {
597 // - read_cache_page()
598 // Again for each page do:
599 // - wait_on_page_locked()
600 // - Check (PageUptodate(page) &&
602 // Update initialized size in the attribute and
604 // Again, for each page do:
605 // __set_page_dirty_buffers();
606 // page_cache_release()
607 // We don't need to wait on the writes.
611 * The current page straddles initialized size. Zero
612 * all non-uptodate buffers and set them uptodate (and
613 * dirty?). Note, there aren't any non-uptodate buffers
614 * if the page is uptodate.
615 * FIXME: For an uptodate page, the buffers may need to
616 * be written out because they were not initialized on
619 if (!PageUptodate(page
)) {
621 // Zero any non-uptodate buffers up to i_size.
622 // Set them uptodate and dirty.
625 // Update initialized size in the attribute and in the
626 // inode (up to i_size).
628 // FIXME: This is inefficient. Try to batch the two
629 // size changes to happen in one go.
630 ntfs_error(vol
->sb
, "Writing beyond initialized size "
631 "is not supported yet. Sorry.");
634 // Do NOT set_buffer_new() BUT DO clear buffer range
635 // outside write request range.
636 // set_buffer_uptodate() on complete buffers as well as
637 // set_buffer_dirty().
640 /* No need to map buffers that are already mapped. */
641 if (buffer_mapped(bh
))
644 /* Unmapped, dirty buffer. Need to map it. */
645 bh
->b_bdev
= vol
->sb
->s_bdev
;
647 /* Convert block into corresponding vcn and offset. */
648 vcn
= (VCN
)block
<< blocksize_bits
;
649 vcn_ofs
= vcn
& vol
->cluster_size_mask
;
650 vcn
>>= vol
->cluster_size_bits
;
653 down_read(&ni
->runlist
.lock
);
656 if (likely(rl
!= NULL
)) {
657 /* Seek to element containing target vcn. */
658 while (rl
->length
&& rl
[1].vcn
<= vcn
)
660 lcn
= ntfs_rl_vcn_to_lcn(rl
, vcn
);
662 lcn
= LCN_RL_NOT_MAPPED
;
663 /* Successful remap. */
665 /* Setup buffer head to point to correct block. */
666 bh
->b_blocknr
= ((lcn
<< vol
->cluster_size_bits
) +
667 vcn_ofs
) >> blocksize_bits
;
668 set_buffer_mapped(bh
);
671 /* It is a hole, need to instantiate it. */
672 if (lcn
== LCN_HOLE
) {
673 // TODO: Instantiate the hole.
674 // clear_buffer_new(bh);
675 // unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
676 ntfs_error(vol
->sb
, "Writing into sparse regions is "
677 "not supported yet. Sorry.");
681 /* If first try and runlist unmapped, map and retry. */
682 if (!is_retry
&& lcn
== LCN_RL_NOT_MAPPED
) {
685 * Attempt to map runlist, dropping lock for
688 up_read(&ni
->runlist
.lock
);
689 err
= ntfs_map_runlist(ni
, vcn
);
691 goto lock_retry_remap
;
695 up_read(&ni
->runlist
.lock
);
696 /* Failed to map the buffer, even after retrying. */
698 ntfs_error(vol
->sb
, "Failed to write to inode 0x%lx, "
699 "attribute type 0x%x, vcn 0x%llx, offset 0x%x "
700 "because its location on disk could not be "
701 "determined%s (error code %lli).", ni
->mft_no
,
702 ni
->type
, (unsigned long long)vcn
,
703 vcn_ofs
, is_retry
? " even after "
704 "retrying" : "", (long long)lcn
);
708 } while (block
++, (bh
= bh
->b_this_page
) != head
);
710 /* Release the lock if we took it. */
712 up_read(&ni
->runlist
.lock
);
714 /* For the error case, need to reset bh to the beginning. */
717 /* Just an optimization, so ->readpage() isn't called later. */
718 if (unlikely(!PageUptodate(page
))) {
721 if (!buffer_uptodate(bh
)) {
726 } while ((bh
= bh
->b_this_page
) != head
);
728 SetPageUptodate(page
);
731 /* Setup all mapped, dirty buffers for async write i/o. */
734 if (buffer_mapped(bh
) && buffer_dirty(bh
)) {
736 if (test_clear_buffer_dirty(bh
)) {
737 BUG_ON(!buffer_uptodate(bh
));
738 mark_buffer_async_write(bh
);
741 } else if (unlikely(err
)) {
743 * For the error case. The buffer may have been set
744 * dirty during attachment to a dirty page.
747 clear_buffer_dirty(bh
);
749 } while ((bh
= bh
->b_this_page
) != head
);
752 // TODO: Remove the -EOPNOTSUPP check later on...
753 if (unlikely(err
== -EOPNOTSUPP
))
755 else if (err
== -ENOMEM
) {
756 ntfs_warning(vol
->sb
, "Error allocating memory. "
757 "Redirtying page so we try again "
760 * Put the page back on mapping->dirty_pages, but
761 * leave its buffer's dirty state as-is.
763 redirty_page_for_writepage(wbc
, page
);
769 BUG_ON(PageWriteback(page
));
770 set_page_writeback(page
); /* Keeps try_to_free_buffers() away. */
774 * Submit the prepared buffers for i/o. Note the page is unlocked,
775 * and the async write i/o completion handler can end_page_writeback()
776 * at any time after the *first* submit_bh(). So the buffers can then
779 need_end_writeback
= TRUE
;
781 struct buffer_head
*next
= bh
->b_this_page
;
782 if (buffer_async_write(bh
)) {
783 submit_bh(WRITE
, bh
);
784 need_end_writeback
= FALSE
;
788 } while (bh
!= head
);
790 /* If no i/o was started, need to end_page_writeback(). */
791 if (unlikely(need_end_writeback
))
792 end_page_writeback(page
);
799 * ntfs_write_mst_block - write a @page to the backing store
800 * @page: page cache page to write out
801 * @wbc: writeback control structure
803 * This function is for writing pages belonging to non-resident, mst protected
804 * attributes to their backing store. The only supported attributes are index
805 * allocation and $MFT/$DATA. Both directory inodes and index inodes are
806 * supported for the index allocation case.
808 * The page must remain locked for the duration of the write because we apply
809 * the mst fixups, write, and then undo the fixups, so if we were to unlock the
810 * page before undoing the fixups, any other user of the page will see the
811 * page contents as corrupt.
813 * We clear the page uptodate flag for the duration of the function to ensure
814 * exclusion for the $MFT/$DATA case against someone mapping an mft record we
815 * are about to apply the mst fixups to.
817 * Return 0 on success and -errno on error.
819 * Based on ntfs_write_block(), ntfs_mft_writepage(), and
820 * write_mft_record_nolock().
822 static int ntfs_write_mst_block(struct page
*page
,
823 struct writeback_control
*wbc
)
825 sector_t block
, dblock
, rec_block
;
826 struct inode
*vi
= page
->mapping
->host
;
827 ntfs_inode
*ni
= NTFS_I(vi
);
828 ntfs_volume
*vol
= ni
->vol
;
830 unsigned int rec_size
= ni
->itype
.index
.block_size
;
831 ntfs_inode
*locked_nis
[PAGE_CACHE_SIZE
/ rec_size
];
832 struct buffer_head
*bh
, *head
, *tbh
, *rec_start_bh
;
833 struct buffer_head
*bhs
[MAX_BUF_PER_PAGE
];
835 int i
, nr_locked_nis
, nr_recs
, nr_bhs
, max_bhs
, bhs_per_rec
, err
, err2
;
836 unsigned bh_size
, rec_size_bits
;
837 BOOL sync
, is_mft
, page_is_dirty
, rec_is_dirty
;
838 unsigned char bh_size_bits
;
840 ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "
841 "0x%lx.", vi
->i_ino
, ni
->type
, page
->index
);
842 BUG_ON(!NInoNonResident(ni
));
843 BUG_ON(!NInoMstProtected(ni
));
844 is_mft
= (S_ISREG(vi
->i_mode
) && !vi
->i_ino
);
846 * NOTE: ntfs_write_mst_block() would be called for $MFTMirr if a page
847 * in its page cache were to be marked dirty. However this should
848 * never happen with the current driver and considering we do not
849 * handle this case here we do want to BUG(), at least for now.
851 BUG_ON(!(is_mft
|| S_ISDIR(vi
->i_mode
) ||
852 (NInoAttr(ni
) && ni
->type
== AT_INDEX_ALLOCATION
)));
853 bh_size_bits
= vi
->i_blkbits
;
854 bh_size
= 1 << bh_size_bits
;
855 max_bhs
= PAGE_CACHE_SIZE
/ bh_size
;
857 BUG_ON(max_bhs
> MAX_BUF_PER_PAGE
);
859 /* Were we called for sync purposes? */
860 sync
= (wbc
->sync_mode
== WB_SYNC_ALL
);
862 /* Make sure we have mapped buffers. */
863 BUG_ON(!page_has_buffers(page
));
864 bh
= head
= page_buffers(page
);
867 rec_size_bits
= ni
->itype
.index
.block_size_bits
;
868 BUG_ON(!(PAGE_CACHE_SIZE
>> rec_size_bits
));
869 bhs_per_rec
= rec_size
>> bh_size_bits
;
870 BUG_ON(!bhs_per_rec
);
872 /* The first block in the page. */
873 rec_block
= block
= (sector_t
)page
->index
<<
874 (PAGE_CACHE_SHIFT
- bh_size_bits
);
876 /* The first out of bounds block for the data size. */
877 dblock
= (i_size_read(vi
) + bh_size
- 1) >> bh_size_bits
;
880 err
= err2
= nr_bhs
= nr_recs
= nr_locked_nis
= 0;
881 page_is_dirty
= rec_is_dirty
= FALSE
;
884 BOOL is_retry
= FALSE
;
886 if (likely(block
< rec_block
)) {
887 if (unlikely(block
>= dblock
)) {
888 clear_buffer_dirty(bh
);
889 set_buffer_uptodate(bh
);
893 * This block is not the first one in the record. We
894 * ignore the buffer's dirty state because we could
895 * have raced with a parallel mark_ntfs_record_dirty().
899 if (unlikely(err2
)) {
901 clear_buffer_dirty(bh
);
904 } else /* if (block == rec_block) */ {
905 BUG_ON(block
> rec_block
);
906 /* This block is the first one in the record. */
907 rec_block
+= bhs_per_rec
;
909 if (unlikely(block
>= dblock
)) {
910 clear_buffer_dirty(bh
);
913 if (!buffer_dirty(bh
)) {
914 /* Clean records are not written out. */
915 rec_is_dirty
= FALSE
;
921 /* Need to map the buffer if it is not mapped already. */
922 if (unlikely(!buffer_mapped(bh
))) {
925 unsigned int vcn_ofs
;
927 bh
->b_bdev
= vol
->sb
->s_bdev
;
928 /* Obtain the vcn and offset of the current block. */
929 vcn
= (VCN
)block
<< bh_size_bits
;
930 vcn_ofs
= vcn
& vol
->cluster_size_mask
;
931 vcn
>>= vol
->cluster_size_bits
;
934 down_read(&ni
->runlist
.lock
);
937 if (likely(rl
!= NULL
)) {
938 /* Seek to element containing target vcn. */
939 while (rl
->length
&& rl
[1].vcn
<= vcn
)
941 lcn
= ntfs_rl_vcn_to_lcn(rl
, vcn
);
943 lcn
= LCN_RL_NOT_MAPPED
;
944 /* Successful remap. */
945 if (likely(lcn
>= 0)) {
946 /* Setup buffer head to correct block. */
947 bh
->b_blocknr
= ((lcn
<<
948 vol
->cluster_size_bits
) +
949 vcn_ofs
) >> bh_size_bits
;
950 set_buffer_mapped(bh
);
953 * Remap failed. Retry to map the runlist once
954 * unless we are working on $MFT which always
955 * has the whole of its runlist in memory.
957 if (!is_mft
&& !is_retry
&&
958 lcn
== LCN_RL_NOT_MAPPED
) {
961 * Attempt to map runlist, dropping
962 * lock for the duration.
964 up_read(&ni
->runlist
.lock
);
965 err2
= ntfs_map_runlist(ni
, vcn
);
967 goto lock_retry_remap
;
969 page_is_dirty
= TRUE
;
974 up_read(&ni
->runlist
.lock
);
976 /* Hard error. Abort writing this record. */
977 if (!err
|| err
== -ENOMEM
)
980 ntfs_error(vol
->sb
, "Cannot write ntfs record "
981 "0x%llx (inode 0x%lx, "
982 "attribute type 0x%x) because "
983 "its location on disk could "
984 "not be determined (error "
988 vol
->mft_record_size_bits
,
989 ni
->mft_no
, ni
->type
,
992 * If this is not the first buffer, remove the
993 * buffers in this record from the list of
994 * buffers to write and clear their dirty bit
995 * if not error -ENOMEM.
997 if (rec_start_bh
!= bh
) {
998 while (bhs
[--nr_bhs
] != rec_start_bh
)
1000 if (err2
!= -ENOMEM
) {
1004 } while ((rec_start_bh
=
1013 BUG_ON(!buffer_uptodate(bh
));
1014 BUG_ON(nr_bhs
>= max_bhs
);
1016 } while (block
++, (bh
= bh
->b_this_page
) != head
);
1018 up_read(&ni
->runlist
.lock
);
1019 /* If there were no dirty buffers, we are done. */
1022 /* Map the page so we can access its contents. */
1024 /* Clear the page uptodate flag whilst the mst fixups are applied. */
1025 BUG_ON(!PageUptodate(page
));
1026 ClearPageUptodate(page
);
1027 for (i
= 0; i
< nr_bhs
; i
++) {
1030 /* Skip buffers which are not at the beginning of records. */
1031 if (i
% bhs_per_rec
)
1034 ofs
= bh_offset(tbh
);
1037 unsigned long mft_no
;
1039 /* Get the mft record number. */
1040 mft_no
= (((s64
)page
->index
<< PAGE_CACHE_SHIFT
) + ofs
)
1042 /* Check whether to write this mft record. */
1044 if (!ntfs_may_write_mft_record(vol
, mft_no
,
1045 (MFT_RECORD
*)(kaddr
+ ofs
), &tni
)) {
1047 * The record should not be written. This
1048 * means we need to redirty the page before
1051 page_is_dirty
= TRUE
;
1053 * Remove the buffers in this mft record from
1054 * the list of buffers to write.
1058 } while (++i
% bhs_per_rec
);
1062 * The record should be written. If a locked ntfs
1063 * inode was returned, add it to the array of locked
1067 locked_nis
[nr_locked_nis
++] = tni
;
1069 /* Apply the mst protection fixups. */
1070 err2
= pre_write_mst_fixup((NTFS_RECORD
*)(kaddr
+ ofs
),
1072 if (unlikely(err2
)) {
1073 if (!err
|| err
== -ENOMEM
)
1075 ntfs_error(vol
->sb
, "Failed to apply mst fixups "
1076 "(inode 0x%lx, attribute type 0x%x, "
1077 "page index 0x%lx, page offset 0x%x)!"
1078 " Unmount and run chkdsk.", vi
->i_ino
,
1079 ni
->type
, page
->index
, ofs
);
1081 * Mark all the buffers in this record clean as we do
1082 * not want to write corrupt data to disk.
1085 clear_buffer_dirty(bhs
[i
]);
1087 } while (++i
% bhs_per_rec
);
1092 /* If no records are to be written out, we are done. */
1095 flush_dcache_page(page
);
1096 /* Lock buffers and start synchronous write i/o on them. */
1097 for (i
= 0; i
< nr_bhs
; i
++) {
1101 if (unlikely(test_set_buffer_locked(tbh
)))
1103 /* The buffer dirty state is now irrelevant, just clean it. */
1104 clear_buffer_dirty(tbh
);
1105 BUG_ON(!buffer_uptodate(tbh
));
1106 BUG_ON(!buffer_mapped(tbh
));
1108 tbh
->b_end_io
= end_buffer_write_sync
;
1109 submit_bh(WRITE
, tbh
);
1111 /* Synchronize the mft mirror now if not @sync. */
1112 if (is_mft
&& !sync
)
1115 /* Wait on i/o completion of buffers. */
1116 for (i
= 0; i
< nr_bhs
; i
++) {
1120 wait_on_buffer(tbh
);
1121 if (unlikely(!buffer_uptodate(tbh
))) {
1122 ntfs_error(vol
->sb
, "I/O error while writing ntfs "
1123 "record buffer (inode 0x%lx, "
1124 "attribute type 0x%x, page index "
1125 "0x%lx, page offset 0x%lx)! Unmount "
1126 "and run chkdsk.", vi
->i_ino
, ni
->type
,
1127 page
->index
, bh_offset(tbh
));
1128 if (!err
|| err
== -ENOMEM
)
1131 * Set the buffer uptodate so the page and buffer
1132 * states do not become out of sync.
1134 set_buffer_uptodate(tbh
);
1137 /* If @sync, now synchronize the mft mirror. */
1138 if (is_mft
&& sync
) {
1140 for (i
= 0; i
< nr_bhs
; i
++) {
1141 unsigned long mft_no
;
1145 * Skip buffers which are not at the beginning of
1148 if (i
% bhs_per_rec
)
1151 /* Skip removed buffers (and hence records). */
1154 ofs
= bh_offset(tbh
);
1155 /* Get the mft record number. */
1156 mft_no
= (((s64
)page
->index
<< PAGE_CACHE_SHIFT
) + ofs
)
1158 if (mft_no
< vol
->mftmirr_size
)
1159 ntfs_sync_mft_mirror(vol
, mft_no
,
1160 (MFT_RECORD
*)(kaddr
+ ofs
),
1166 /* Remove the mst protection fixups again. */
1167 for (i
= 0; i
< nr_bhs
; i
++) {
1168 if (!(i
% bhs_per_rec
)) {
1172 post_write_mst_fixup((NTFS_RECORD
*)(kaddr
+
1176 flush_dcache_page(page
);
1178 /* Unlock any locked inodes. */
1179 while (nr_locked_nis
-- > 0) {
1180 ntfs_inode
*tni
, *base_tni
;
1182 tni
= locked_nis
[nr_locked_nis
];
1183 /* Get the base inode. */
1184 down(&tni
->extent_lock
);
1185 if (tni
->nr_extents
>= 0)
1188 base_tni
= tni
->ext
.base_ntfs_ino
;
1191 up(&tni
->extent_lock
);
1192 ntfs_debug("Unlocking %s inode 0x%lx.",
1193 tni
== base_tni
? "base" : "extent",
1195 up(&tni
->mrec_lock
);
1196 atomic_dec(&tni
->count
);
1197 iput(VFS_I(base_tni
));
1199 SetPageUptodate(page
);
1202 if (unlikely(err
&& err
!= -ENOMEM
)) {
1204 * Set page error if there is only one ntfs record in the page.
1205 * Otherwise we would loose per-record granularity.
1207 if (ni
->itype
.index
.block_size
== PAGE_CACHE_SIZE
)
1211 if (page_is_dirty
) {
1212 ntfs_debug("Page still contains one or more dirty ntfs "
1213 "records. Redirtying the page starting at "
1214 "record 0x%lx.", page
->index
<<
1215 (PAGE_CACHE_SHIFT
- rec_size_bits
));
1216 redirty_page_for_writepage(wbc
, page
);
1220 * Keep the VM happy. This must be done otherwise the
1221 * radix-tree tag PAGECACHE_TAG_DIRTY remains set even though
1222 * the page is clean.
1224 BUG_ON(PageWriteback(page
));
1225 set_page_writeback(page
);
1227 end_page_writeback(page
);
1230 ntfs_debug("Done.");
1235 * ntfs_writepage - write a @page to the backing store
1236 * @page: page cache page to write out
1237 * @wbc: writeback control structure
1239 * This is called from the VM when it wants to have a dirty ntfs page cache
1240 * page cleaned. The VM has already locked the page and marked it clean.
1242 * For non-resident attributes, ntfs_writepage() writes the @page by calling
1243 * the ntfs version of the generic block_write_full_page() function,
1244 * ntfs_write_block(), which in turn if necessary creates and writes the
1245 * buffers associated with the page asynchronously.
1247 * For resident attributes, OTOH, ntfs_writepage() writes the @page by copying
1248 * the data to the mft record (which at this stage is most likely in memory).
1249 * The mft record is then marked dirty and written out asynchronously via the
1250 * vfs inode dirty code path for the inode the mft record belongs to or via the
1251 * vm page dirty code path for the page the mft record is in.
1253 * Based on ntfs_readpage() and fs/buffer.c::block_write_full_page().
1255 * Return 0 on success and -errno on error.
1257 static int ntfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1260 struct inode
*vi
= page
->mapping
->host
;
1261 ntfs_inode
*base_ni
= NULL
, *ni
= NTFS_I(vi
);
1263 ntfs_attr_search_ctx
*ctx
= NULL
;
1264 MFT_RECORD
*m
= NULL
;
1269 BUG_ON(!PageLocked(page
));
1270 i_size
= i_size_read(vi
);
1271 /* Is the page fully outside i_size? (truncate in progress) */
1272 if (unlikely(page
->index
>= (i_size
+ PAGE_CACHE_SIZE
- 1) >>
1273 PAGE_CACHE_SHIFT
)) {
1275 * The page may have dirty, unmapped buffers. Make them
1276 * freeable here, so the page does not leak.
1278 block_invalidatepage(page
, 0);
1280 ntfs_debug("Write outside i_size - truncated?");
1283 /* NInoNonResident() == NInoIndexAllocPresent() */
1284 if (NInoNonResident(ni
)) {
1286 * Only unnamed $DATA attributes can be compressed, encrypted,
1289 if (ni
->type
== AT_DATA
&& !ni
->name_len
) {
1290 /* If file is encrypted, deny access, just like NT4. */
1291 if (NInoEncrypted(ni
)) {
1293 ntfs_debug("Denying write access to encrypted "
1297 /* Compressed data streams are handled in compress.c. */
1298 if (NInoCompressed(ni
)) {
1299 // TODO: Implement and replace this check with
1300 // return ntfs_write_compressed_block(page);
1302 ntfs_error(vi
->i_sb
, "Writing to compressed "
1303 "files is not supported yet. "
1307 // TODO: Implement and remove this check.
1308 if (NInoSparse(ni
)) {
1310 ntfs_error(vi
->i_sb
, "Writing to sparse files "
1311 "is not supported yet. Sorry.");
1315 /* We have to zero every time due to mmap-at-end-of-file. */
1316 if (page
->index
>= (i_size
>> PAGE_CACHE_SHIFT
)) {
1317 /* The page straddles i_size. */
1318 unsigned int ofs
= i_size
& ~PAGE_CACHE_MASK
;
1319 kaddr
= kmap_atomic(page
, KM_USER0
);
1320 memset(kaddr
+ ofs
, 0, PAGE_CACHE_SIZE
- ofs
);
1321 flush_dcache_page(page
);
1322 kunmap_atomic(kaddr
, KM_USER0
);
1324 /* Handle mst protected attributes. */
1325 if (NInoMstProtected(ni
))
1326 return ntfs_write_mst_block(page
, wbc
);
1327 /* Normal data stream. */
1328 return ntfs_write_block(page
, wbc
);
1331 * Attribute is resident, implying it is not compressed, encrypted,
1332 * sparse, or mst protected. This also means the attribute is smaller
1333 * than an mft record and hence smaller than a page, so can simply
1334 * return error on any pages with index above 0.
1336 BUG_ON(page_has_buffers(page
));
1337 BUG_ON(!PageUptodate(page
));
1338 if (unlikely(page
->index
> 0)) {
1339 ntfs_error(vi
->i_sb
, "BUG()! page->index (0x%lx) > 0. "
1340 "Aborting write.", page
->index
);
1341 BUG_ON(PageWriteback(page
));
1342 set_page_writeback(page
);
1344 end_page_writeback(page
);
1350 base_ni
= ni
->ext
.base_ntfs_ino
;
1351 /* Map, pin, and lock the mft record. */
1352 m
= map_mft_record(base_ni
);
1360 * If a parallel write made the attribute non-resident, drop the mft
1361 * record and retry the writepage.
1363 if (unlikely(NInoNonResident(ni
))) {
1364 unmap_mft_record(base_ni
);
1365 goto retry_writepage
;
1367 ctx
= ntfs_attr_get_search_ctx(base_ni
, m
);
1368 if (unlikely(!ctx
)) {
1372 err
= ntfs_attr_lookup(ni
->type
, ni
->name
, ni
->name_len
,
1373 CASE_SENSITIVE
, 0, NULL
, 0, ctx
);
1377 * Keep the VM happy. This must be done otherwise the radix-tree tag
1378 * PAGECACHE_TAG_DIRTY remains set even though the page is clean.
1380 BUG_ON(PageWriteback(page
));
1381 set_page_writeback(page
);
1385 * Here, we don't need to zero the out of bounds area everytime because
1386 * the below memcpy() already takes care of the mmap-at-end-of-file
1387 * requirements. If the file is converted to a non-resident one, then
1388 * the code path use is switched to the non-resident one where the
1389 * zeroing happens on each ntfs_writepage() invocation.
1391 * The above also applies nicely when i_size is decreased.
1393 * When i_size is increased, the memory between the old and new i_size
1394 * _must_ be zeroed (or overwritten with new data). Otherwise we will
1395 * expose data to userspace/disk which should never have been exposed.
1397 * FIXME: Ensure that i_size increases do the zeroing/overwriting and
1398 * if we cannot guarantee that, then enable the zeroing below. If the
1399 * zeroing below is enabled, we MUST move the unlock_page() from above
1400 * to after the kunmap_atomic(), i.e. just before the
1401 * end_page_writeback().
1402 * UPDATE: ntfs_prepare/commit_write() do the zeroing on i_size
1403 * increases for resident attributes so those are ok.
1404 * TODO: ntfs_truncate(), others?
1407 attr_len
= le32_to_cpu(ctx
->attr
->data
.resident
.value_length
);
1408 i_size
= i_size_read(vi
);
1409 if (unlikely(attr_len
> i_size
)) {
1411 ctx
->attr
->data
.resident
.value_length
= cpu_to_le32(attr_len
);
1413 kaddr
= kmap_atomic(page
, KM_USER0
);
1414 /* Copy the data from the page to the mft record. */
1415 memcpy((u8
*)ctx
->attr
+
1416 le16_to_cpu(ctx
->attr
->data
.resident
.value_offset
),
1418 flush_dcache_mft_record_page(ctx
->ntfs_ino
);
1419 /* Zero out of bounds area in the page cache page. */
1420 memset(kaddr
+ attr_len
, 0, PAGE_CACHE_SIZE
- attr_len
);
1421 flush_dcache_page(page
);
1422 kunmap_atomic(kaddr
, KM_USER0
);
1424 end_page_writeback(page
);
1426 /* Mark the mft record dirty, so it gets written back. */
1427 mark_mft_record_dirty(ctx
->ntfs_ino
);
1428 ntfs_attr_put_search_ctx(ctx
);
1429 unmap_mft_record(base_ni
);
1432 if (err
== -ENOMEM
) {
1433 ntfs_warning(vi
->i_sb
, "Error allocating memory. Redirtying "
1434 "page so we try again later.");
1436 * Put the page back on mapping->dirty_pages, but leave its
1437 * buffers' dirty state as-is.
1439 redirty_page_for_writepage(wbc
, page
);
1442 ntfs_error(vi
->i_sb
, "Resident attribute write failed with "
1445 NVolSetErrors(ni
->vol
);
1450 ntfs_attr_put_search_ctx(ctx
);
1452 unmap_mft_record(base_ni
);
1457 * ntfs_prepare_nonresident_write -
1460 static int ntfs_prepare_nonresident_write(struct page
*page
,
1461 unsigned from
, unsigned to
)
1465 s64 initialized_size
;
1467 sector_t block
, ablock
, iblock
;
1471 runlist_element
*rl
;
1472 struct buffer_head
*bh
, *head
, *wait
[2], **wait_bh
= wait
;
1473 unsigned long flags
;
1474 unsigned int vcn_ofs
, block_start
, block_end
, blocksize
;
1477 unsigned char blocksize_bits
;
1479 vi
= page
->mapping
->host
;
1483 ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "
1484 "0x%lx, from = %u, to = %u.", ni
->mft_no
, ni
->type
,
1485 page
->index
, from
, to
);
1487 BUG_ON(!NInoNonResident(ni
));
1489 blocksize_bits
= vi
->i_blkbits
;
1490 blocksize
= 1 << blocksize_bits
;
1493 * create_empty_buffers() will create uptodate/dirty buffers if the
1494 * page is uptodate/dirty.
1496 if (!page_has_buffers(page
))
1497 create_empty_buffers(page
, blocksize
, 0);
1498 bh
= head
= page_buffers(page
);
1502 /* The first block in the page. */
1503 block
= (s64
)page
->index
<< (PAGE_CACHE_SHIFT
- blocksize_bits
);
1505 read_lock_irqsave(&ni
->size_lock
, flags
);
1507 * The first out of bounds block for the allocated size. No need to
1508 * round up as allocated_size is in multiples of cluster size and the
1509 * minimum cluster size is 512 bytes, which is equal to the smallest
1512 ablock
= ni
->allocated_size
>> blocksize_bits
;
1513 i_size
= i_size_read(vi
);
1514 initialized_size
= ni
->initialized_size
;
1515 read_unlock_irqrestore(&ni
->size_lock
, flags
);
1517 /* The last (fully or partially) initialized block. */
1518 iblock
= initialized_size
>> blocksize_bits
;
1520 /* Loop through all the buffers in the page. */
1525 block_end
= block_start
+ blocksize
;
1527 * If buffer @bh is outside the write, just mark it uptodate
1528 * if the page is uptodate and continue with the next buffer.
1530 if (block_end
<= from
|| block_start
>= to
) {
1531 if (PageUptodate(page
)) {
1532 if (!buffer_uptodate(bh
))
1533 set_buffer_uptodate(bh
);
1538 * @bh is at least partially being written to.
1539 * Make sure it is not marked as new.
1541 //if (buffer_new(bh))
1542 // clear_buffer_new(bh);
1544 if (block
>= ablock
) {
1545 // TODO: block is above allocated_size, need to
1546 // allocate it. Best done in one go to accommodate not
1547 // only block but all above blocks up to and including:
1548 // ((page->index << PAGE_CACHE_SHIFT) + to + blocksize
1549 // - 1) >> blobksize_bits. Obviously will need to round
1550 // up to next cluster boundary, too. This should be
1551 // done with a helper function, so it can be reused.
1552 ntfs_error(vol
->sb
, "Writing beyond allocated size "
1553 "is not supported yet. Sorry.");
1556 // Need to update ablock.
1557 // Need to set_buffer_new() on all block bhs that are
1561 * Now we have enough allocated size to fulfill the whole
1562 * request, i.e. block < ablock is true.
1564 if (unlikely((block
>= iblock
) &&
1565 (initialized_size
< i_size
))) {
1567 * If this page is fully outside initialized size, zero
1568 * out all pages between the current initialized size
1569 * and the current page. Just use ntfs_readpage() to do
1570 * the zeroing transparently.
1572 if (block
> iblock
) {
1574 // For each page do:
1575 // - read_cache_page()
1576 // Again for each page do:
1577 // - wait_on_page_locked()
1578 // - Check (PageUptodate(page) &&
1579 // !PageError(page))
1580 // Update initialized size in the attribute and
1582 // Again, for each page do:
1583 // __set_page_dirty_buffers();
1584 // page_cache_release()
1585 // We don't need to wait on the writes.
1589 * The current page straddles initialized size. Zero
1590 * all non-uptodate buffers and set them uptodate (and
1591 * dirty?). Note, there aren't any non-uptodate buffers
1592 * if the page is uptodate.
1593 * FIXME: For an uptodate page, the buffers may need to
1594 * be written out because they were not initialized on
1597 if (!PageUptodate(page
)) {
1599 // Zero any non-uptodate buffers up to i_size.
1600 // Set them uptodate and dirty.
1603 // Update initialized size in the attribute and in the
1604 // inode (up to i_size).
1606 // FIXME: This is inefficient. Try to batch the two
1607 // size changes to happen in one go.
1608 ntfs_error(vol
->sb
, "Writing beyond initialized size "
1609 "is not supported yet. Sorry.");
1612 // Do NOT set_buffer_new() BUT DO clear buffer range
1613 // outside write request range.
1614 // set_buffer_uptodate() on complete buffers as well as
1615 // set_buffer_dirty().
1618 /* Need to map unmapped buffers. */
1619 if (!buffer_mapped(bh
)) {
1620 /* Unmapped buffer. Need to map it. */
1621 bh
->b_bdev
= vol
->sb
->s_bdev
;
1623 /* Convert block into corresponding vcn and offset. */
1624 vcn
= (VCN
)block
<< blocksize_bits
>>
1625 vol
->cluster_size_bits
;
1626 vcn_ofs
= ((VCN
)block
<< blocksize_bits
) &
1627 vol
->cluster_size_mask
;
1632 down_read(&ni
->runlist
.lock
);
1633 rl
= ni
->runlist
.rl
;
1635 if (likely(rl
!= NULL
)) {
1636 /* Seek to element containing target vcn. */
1637 while (rl
->length
&& rl
[1].vcn
<= vcn
)
1639 lcn
= ntfs_rl_vcn_to_lcn(rl
, vcn
);
1641 lcn
= LCN_RL_NOT_MAPPED
;
1642 if (unlikely(lcn
< 0)) {
1644 * We extended the attribute allocation above.
1645 * If we hit an ENOENT here it means that the
1646 * allocation was insufficient which is a bug.
1648 BUG_ON(lcn
== LCN_ENOENT
);
1650 /* It is a hole, need to instantiate it. */
1651 if (lcn
== LCN_HOLE
) {
1652 // TODO: Instantiate the hole.
1653 // clear_buffer_new(bh);
1654 // unmap_underlying_metadata(bh->b_bdev,
1656 // For non-uptodate buffers, need to
1657 // zero out the region outside the
1658 // request in this bh or all bhs,
1659 // depending on what we implemented
1661 // Need to flush_dcache_page().
1662 // Or could use set_buffer_new()
1664 ntfs_error(vol
->sb
, "Writing into "
1665 "sparse regions is "
1666 "not supported yet. "
1670 up_read(&ni
->runlist
.lock
);
1672 } else if (!is_retry
&&
1673 lcn
== LCN_RL_NOT_MAPPED
) {
1676 * Attempt to map runlist, dropping
1677 * lock for the duration.
1679 up_read(&ni
->runlist
.lock
);
1680 err
= ntfs_map_runlist(ni
, vcn
);
1682 goto lock_retry_remap
;
1686 up_read(&ni
->runlist
.lock
);
1688 * Failed to map the buffer, even after
1692 ntfs_error(vol
->sb
, "Failed to write to inode "
1693 "0x%lx, attribute type 0x%x, "
1694 "vcn 0x%llx, offset 0x%x "
1695 "because its location on disk "
1696 "could not be determined%s "
1697 "(error code %lli).",
1698 ni
->mft_no
, ni
->type
,
1699 (unsigned long long)vcn
,
1700 vcn_ofs
, is_retry
? " even "
1701 "after retrying" : "",
1707 /* We now have a successful remap, i.e. lcn >= 0. */
1709 /* Setup buffer head to correct block. */
1710 bh
->b_blocknr
= ((lcn
<< vol
->cluster_size_bits
)
1711 + vcn_ofs
) >> blocksize_bits
;
1712 set_buffer_mapped(bh
);
1714 // FIXME: Something analogous to this is needed for
1715 // each newly allocated block, i.e. BH_New.
1716 // FIXME: Might need to take this out of the
1717 // if (!buffer_mapped(bh)) {}, depending on how we
1718 // implement things during the allocated_size and
1719 // initialized_size extension code above.
1720 if (buffer_new(bh
)) {
1721 clear_buffer_new(bh
);
1722 unmap_underlying_metadata(bh
->b_bdev
,
1724 if (PageUptodate(page
)) {
1725 set_buffer_uptodate(bh
);
1729 * Page is _not_ uptodate, zero surrounding
1730 * region. NOTE: This is how we decide if to
1733 if (block_end
> to
|| block_start
< from
) {
1736 kaddr
= kmap_atomic(page
, KM_USER0
);
1738 memset(kaddr
+ to
, 0,
1740 if (block_start
< from
)
1741 memset(kaddr
+ block_start
, 0,
1744 flush_dcache_page(page
);
1745 kunmap_atomic(kaddr
, KM_USER0
);
1750 /* @bh is mapped, set it uptodate if the page is uptodate. */
1751 if (PageUptodate(page
)) {
1752 if (!buffer_uptodate(bh
))
1753 set_buffer_uptodate(bh
);
1757 * The page is not uptodate. The buffer is mapped. If it is not
1758 * uptodate, and it is only partially being written to, we need
1759 * to read the buffer in before the write, i.e. right now.
1761 if (!buffer_uptodate(bh
) &&
1762 (block_start
< from
|| block_end
> to
)) {
1763 ll_rw_block(READ
, 1, &bh
);
1766 } while (block
++, block_start
= block_end
,
1767 (bh
= bh
->b_this_page
) != head
);
1769 /* Release the lock if we took it. */
1771 up_read(&ni
->runlist
.lock
);
1775 /* If we issued read requests, let them complete. */
1776 while (wait_bh
> wait
) {
1777 wait_on_buffer(*--wait_bh
);
1778 if (!buffer_uptodate(*wait_bh
))
1782 ntfs_debug("Done.");
1786 * Zero out any newly allocated blocks to avoid exposing stale data.
1787 * If BH_New is set, we know that the block was newly allocated in the
1789 * FIXME: What about initialized_size increments? Have we done all the
1790 * required zeroing above? If not this error handling is broken, and
1791 * in particular the if (block_end <= from) check is completely bogus.
1797 block_end
= block_start
+ blocksize
;
1798 if (block_end
<= from
)
1800 if (block_start
>= to
)
1802 if (buffer_new(bh
)) {
1805 clear_buffer_new(bh
);
1806 kaddr
= kmap_atomic(page
, KM_USER0
);
1807 memset(kaddr
+ block_start
, 0, bh
->b_size
);
1808 kunmap_atomic(kaddr
, KM_USER0
);
1809 set_buffer_uptodate(bh
);
1810 mark_buffer_dirty(bh
);
1813 } while (block_start
= block_end
, (bh
= bh
->b_this_page
) != head
);
1815 flush_dcache_page(page
);
1817 up_read(&ni
->runlist
.lock
);
1822 * ntfs_prepare_write - prepare a page for receiving data
1824 * This is called from generic_file_write() with i_sem held on the inode
1825 * (@page->mapping->host). The @page is locked but not kmap()ped. The source
1826 * data has not yet been copied into the @page.
1828 * Need to extend the attribute/fill in holes if necessary, create blocks and
1829 * make partially overwritten blocks uptodate,
1831 * i_size is not to be modified yet.
1833 * Return 0 on success or -errno on error.
1835 * Should be using block_prepare_write() [support for sparse files] or
1836 * cont_prepare_write() [no support for sparse files]. Cannot do that due to
1837 * ntfs specifics but can look at them for implementation guidance.
1839 * Note: In the range, @from is inclusive and @to is exclusive, i.e. @from is
1840 * the first byte in the page that will be written to and @to is the first byte
1841 * after the last byte that will be written to.
1843 static int ntfs_prepare_write(struct file
*file
, struct page
*page
,
1844 unsigned from
, unsigned to
)
1848 struct inode
*vi
= page
->mapping
->host
;
1849 ntfs_inode
*base_ni
= NULL
, *ni
= NTFS_I(vi
);
1850 ntfs_volume
*vol
= ni
->vol
;
1851 ntfs_attr_search_ctx
*ctx
= NULL
;
1852 MFT_RECORD
*m
= NULL
;
1858 ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "
1859 "0x%lx, from = %u, to = %u.", vi
->i_ino
, ni
->type
,
1860 page
->index
, from
, to
);
1861 BUG_ON(!PageLocked(page
));
1862 BUG_ON(from
> PAGE_CACHE_SIZE
);
1863 BUG_ON(to
> PAGE_CACHE_SIZE
);
1865 BUG_ON(NInoMstProtected(ni
));
1867 * If a previous ntfs_truncate() failed, repeat it and abort if it
1870 if (unlikely(NInoTruncateFailed(ni
))) {
1871 down_write(&vi
->i_alloc_sem
);
1872 err
= ntfs_truncate(vi
);
1873 up_write(&vi
->i_alloc_sem
);
1874 if (err
|| NInoTruncateFailed(ni
)) {
1880 /* If the attribute is not resident, deal with it elsewhere. */
1881 if (NInoNonResident(ni
)) {
1883 * Only unnamed $DATA attributes can be compressed, encrypted,
1886 if (ni
->type
== AT_DATA
&& !ni
->name_len
) {
1887 /* If file is encrypted, deny access, just like NT4. */
1888 if (NInoEncrypted(ni
)) {
1889 ntfs_debug("Denying write access to encrypted "
1893 /* Compressed data streams are handled in compress.c. */
1894 if (NInoCompressed(ni
)) {
1895 // TODO: Implement and replace this check with
1896 // return ntfs_write_compressed_block(page);
1897 ntfs_error(vi
->i_sb
, "Writing to compressed "
1898 "files is not supported yet. "
1902 // TODO: Implement and remove this check.
1903 if (NInoSparse(ni
)) {
1904 ntfs_error(vi
->i_sb
, "Writing to sparse files "
1905 "is not supported yet. Sorry.");
1909 /* Normal data stream. */
1910 return ntfs_prepare_nonresident_write(page
, from
, to
);
1913 * Attribute is resident, implying it is not compressed, encrypted, or
1916 BUG_ON(page_has_buffers(page
));
1917 new_size
= ((s64
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
1918 /* If we do not need to resize the attribute allocation we are done. */
1919 if (new_size
<= i_size_read(vi
))
1921 /* Map, pin, and lock the (base) mft record. */
1925 base_ni
= ni
->ext
.base_ntfs_ino
;
1926 m
= map_mft_record(base_ni
);
1933 ctx
= ntfs_attr_get_search_ctx(base_ni
, m
);
1934 if (unlikely(!ctx
)) {
1938 err
= ntfs_attr_lookup(ni
->type
, ni
->name
, ni
->name_len
,
1939 CASE_SENSITIVE
, 0, NULL
, 0, ctx
);
1940 if (unlikely(err
)) {
1947 /* The total length of the attribute value. */
1948 attr_len
= le32_to_cpu(a
->data
.resident
.value_length
);
1949 /* Fix an eventual previous failure of ntfs_commit_write(). */
1950 i_size
= i_size_read(vi
);
1951 if (unlikely(attr_len
> i_size
)) {
1953 a
->data
.resident
.value_length
= cpu_to_le32(attr_len
);
1955 /* If we do not need to resize the attribute allocation we are done. */
1956 if (new_size
<= attr_len
)
1958 /* Check if new size is allowed in $AttrDef. */
1959 err
= ntfs_attr_size_bounds_check(vol
, ni
->type
, new_size
);
1960 if (unlikely(err
)) {
1961 if (err
== -ERANGE
) {
1962 ntfs_error(vol
->sb
, "Write would cause the inode "
1963 "0x%lx to exceed the maximum size for "
1964 "its attribute type (0x%x). Aborting "
1965 "write.", vi
->i_ino
,
1966 le32_to_cpu(ni
->type
));
1968 ntfs_error(vol
->sb
, "Inode 0x%lx has unknown "
1969 "attribute type 0x%x. Aborting "
1970 "write.", vi
->i_ino
,
1971 le32_to_cpu(ni
->type
));
1977 * Extend the attribute record to be able to store the new attribute
1980 if (new_size
>= vol
->mft_record_size
|| ntfs_attr_record_resize(m
, a
,
1981 le16_to_cpu(a
->data
.resident
.value_offset
) +
1983 /* Not enough space in the mft record. */
1984 ntfs_error(vol
->sb
, "Not enough space in the mft record for "
1985 "the resized attribute value. This is not "
1986 "supported yet. Aborting write.");
1991 * We have enough space in the mft record to fit the write. This
1992 * implies the attribute is smaller than the mft record and hence the
1993 * attribute must be in a single page and hence page->index must be 0.
1995 BUG_ON(page
->index
);
1997 * If the beginning of the write is past the old size, enlarge the
1998 * attribute value up to the beginning of the write and fill it with
2001 if (from
> attr_len
) {
2002 memset((u8
*)a
+ le16_to_cpu(a
->data
.resident
.value_offset
) +
2003 attr_len
, 0, from
- attr_len
);
2004 a
->data
.resident
.value_length
= cpu_to_le32(from
);
2005 /* Zero the corresponding area in the page as well. */
2006 if (PageUptodate(page
)) {
2007 kaddr
= kmap_atomic(page
, KM_USER0
);
2008 memset(kaddr
+ attr_len
, 0, from
- attr_len
);
2009 kunmap_atomic(kaddr
, KM_USER0
);
2010 flush_dcache_page(page
);
2013 flush_dcache_mft_record_page(ctx
->ntfs_ino
);
2014 mark_mft_record_dirty(ctx
->ntfs_ino
);
2016 ntfs_attr_put_search_ctx(ctx
);
2017 unmap_mft_record(base_ni
);
2019 * Because resident attributes are handled by memcpy() to/from the
2020 * corresponding MFT record, and because this form of i/o is byte
2021 * aligned rather than block aligned, there is no need to bring the
2022 * page uptodate here as in the non-resident case where we need to
2023 * bring the buffers straddled by the write uptodate before
2024 * generic_file_write() does the copying from userspace.
2026 * We thus defer the uptodate bringing of the page region outside the
2027 * region written to to ntfs_commit_write(), which makes the code
2028 * simpler and saves one atomic kmap which is good.
2031 ntfs_debug("Done.");
2035 ntfs_warning(vi
->i_sb
, "Error allocating memory required to "
2036 "prepare the write.");
2038 ntfs_error(vi
->i_sb
, "Resident attribute prepare write failed "
2039 "with error %i.", err
);
2045 ntfs_attr_put_search_ctx(ctx
);
2047 unmap_mft_record(base_ni
);
2052 * ntfs_commit_nonresident_write -
2055 static int ntfs_commit_nonresident_write(struct page
*page
,
2056 unsigned from
, unsigned to
)
2058 s64 pos
= ((s64
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
2059 struct inode
*vi
= page
->mapping
->host
;
2060 struct buffer_head
*bh
, *head
;
2061 unsigned int block_start
, block_end
, blocksize
;
2064 ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "
2065 "0x%lx, from = %u, to = %u.", vi
->i_ino
,
2066 NTFS_I(vi
)->type
, page
->index
, from
, to
);
2067 blocksize
= 1 << vi
->i_blkbits
;
2069 // FIXME: We need a whole slew of special cases in here for compressed
2070 // files for example...
2071 // For now, we know ntfs_prepare_write() would have failed so we can't
2072 // get here in any of the cases which we have to special case, so we
2073 // are just a ripped off, unrolled generic_commit_write().
2075 bh
= head
= page_buffers(page
);
2079 block_end
= block_start
+ blocksize
;
2080 if (block_end
<= from
|| block_start
>= to
) {
2081 if (!buffer_uptodate(bh
))
2084 set_buffer_uptodate(bh
);
2085 mark_buffer_dirty(bh
);
2087 } while (block_start
= block_end
, (bh
= bh
->b_this_page
) != head
);
2089 * If this is a partial write which happened to make all buffers
2090 * uptodate then we can optimize away a bogus ->readpage() for the next
2091 * read(). Here we 'discover' whether the page went uptodate as a
2092 * result of this (potentially partial) write.
2095 SetPageUptodate(page
);
2097 * Not convinced about this at all. See disparity comment above. For
2098 * now we know ntfs_prepare_write() would have failed in the write
2099 * exceeds i_size case, so this will never trigger which is fine.
2101 if (pos
> i_size_read(vi
)) {
2102 ntfs_error(vi
->i_sb
, "Writing beyond the existing file size is "
2103 "not supported yet. Sorry.");
2105 // vi->i_size = pos;
2106 // mark_inode_dirty(vi);
2108 ntfs_debug("Done.");
2113 * ntfs_commit_write - commit the received data
2115 * This is called from generic_file_write() with i_sem held on the inode
2116 * (@page->mapping->host). The @page is locked but not kmap()ped. The source
2117 * data has already been copied into the @page. ntfs_prepare_write() has been
2118 * called before the data copied and it returned success so we can take the
2119 * results of various BUG checks and some error handling for granted.
2121 * Need to mark modified blocks dirty so they get written out later when
2122 * ntfs_writepage() is invoked by the VM.
2124 * Return 0 on success or -errno on error.
2126 * Should be using generic_commit_write(). This marks buffers uptodate and
2127 * dirty, sets the page uptodate if all buffers in the page are uptodate, and
2128 * updates i_size if the end of io is beyond i_size. In that case, it also
2129 * marks the inode dirty.
2131 * Cannot use generic_commit_write() due to ntfs specialities but can look at
2132 * it for implementation guidance.
2134 * If things have gone as outlined in ntfs_prepare_write(), then we do not
2135 * need to do any page content modifications here at all, except in the write
2136 * to resident attribute case, where we need to do the uptodate bringing here
2137 * which we combine with the copying into the mft record which means we save
2140 static int ntfs_commit_write(struct file
*file
, struct page
*page
,
2141 unsigned from
, unsigned to
)
2143 struct inode
*vi
= page
->mapping
->host
;
2144 ntfs_inode
*base_ni
, *ni
= NTFS_I(vi
);
2145 char *kaddr
, *kattr
;
2146 ntfs_attr_search_ctx
*ctx
;
2152 ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "
2153 "0x%lx, from = %u, to = %u.", vi
->i_ino
, ni
->type
,
2154 page
->index
, from
, to
);
2155 /* If the attribute is not resident, deal with it elsewhere. */
2156 if (NInoNonResident(ni
)) {
2157 /* Only unnamed $DATA attributes can be compressed/encrypted. */
2158 if (ni
->type
== AT_DATA
&& !ni
->name_len
) {
2159 /* Encrypted files need separate handling. */
2160 if (NInoEncrypted(ni
)) {
2161 // We never get here at present!
2164 /* Compressed data streams are handled in compress.c. */
2165 if (NInoCompressed(ni
)) {
2166 // TODO: Implement this!
2167 // return ntfs_write_compressed_block(page);
2168 // We never get here at present!
2172 /* Normal data stream. */
2173 return ntfs_commit_nonresident_write(page
, from
, to
);
2176 * Attribute is resident, implying it is not compressed, encrypted, or
2182 base_ni
= ni
->ext
.base_ntfs_ino
;
2183 /* Map, pin, and lock the mft record. */
2184 m
= map_mft_record(base_ni
);
2191 ctx
= ntfs_attr_get_search_ctx(base_ni
, m
);
2192 if (unlikely(!ctx
)) {
2196 err
= ntfs_attr_lookup(ni
->type
, ni
->name
, ni
->name_len
,
2197 CASE_SENSITIVE
, 0, NULL
, 0, ctx
);
2198 if (unlikely(err
)) {
2204 /* The total length of the attribute value. */
2205 attr_len
= le32_to_cpu(a
->data
.resident
.value_length
);
2206 BUG_ON(from
> attr_len
);
2207 kattr
= (u8
*)a
+ le16_to_cpu(a
->data
.resident
.value_offset
);
2208 kaddr
= kmap_atomic(page
, KM_USER0
);
2209 /* Copy the received data from the page to the mft record. */
2210 memcpy(kattr
+ from
, kaddr
+ from
, to
- from
);
2211 /* Update the attribute length if necessary. */
2212 if (to
> attr_len
) {
2214 a
->data
.resident
.value_length
= cpu_to_le32(attr_len
);
2217 * If the page is not uptodate, bring the out of bounds area(s)
2218 * uptodate by copying data from the mft record to the page.
2220 if (!PageUptodate(page
)) {
2222 memcpy(kaddr
, kattr
, from
);
2224 memcpy(kaddr
+ to
, kattr
+ to
, attr_len
- to
);
2225 /* Zero the region outside the end of the attribute value. */
2226 if (attr_len
< PAGE_CACHE_SIZE
)
2227 memset(kaddr
+ attr_len
, 0, PAGE_CACHE_SIZE
- attr_len
);
2229 * The probability of not having done any of the above is
2230 * extremely small, so we just flush unconditionally.
2232 flush_dcache_page(page
);
2233 SetPageUptodate(page
);
2235 kunmap_atomic(kaddr
, KM_USER0
);
2236 /* Update i_size if necessary. */
2237 if (i_size_read(vi
) < attr_len
) {
2238 unsigned long flags
;
2240 write_lock_irqsave(&ni
->size_lock
, flags
);
2241 ni
->allocated_size
= ni
->initialized_size
= attr_len
;
2242 i_size_write(vi
, attr_len
);
2243 write_unlock_irqrestore(&ni
->size_lock
, flags
);
2245 /* Mark the mft record dirty, so it gets written back. */
2246 flush_dcache_mft_record_page(ctx
->ntfs_ino
);
2247 mark_mft_record_dirty(ctx
->ntfs_ino
);
2248 ntfs_attr_put_search_ctx(ctx
);
2249 unmap_mft_record(base_ni
);
2250 ntfs_debug("Done.");
2253 if (err
== -ENOMEM
) {
2254 ntfs_warning(vi
->i_sb
, "Error allocating memory required to "
2255 "commit the write.");
2256 if (PageUptodate(page
)) {
2257 ntfs_warning(vi
->i_sb
, "Page is uptodate, setting "
2258 "dirty so the write will be retried "
2259 "later on by the VM.");
2261 * Put the page on mapping->dirty_pages, but leave its
2262 * buffers' dirty state as-is.
2264 __set_page_dirty_nobuffers(page
);
2267 ntfs_error(vi
->i_sb
, "Page is not uptodate. Written "
2268 "data has been lost.");
2270 ntfs_error(vi
->i_sb
, "Resident attribute commit write failed "
2271 "with error %i.", err
);
2272 NVolSetErrors(ni
->vol
);
2276 ntfs_attr_put_search_ctx(ctx
);
2278 unmap_mft_record(base_ni
);
2282 #endif /* NTFS_RW */
2285 * ntfs_aops - general address space operations for inodes and attributes
2287 struct address_space_operations ntfs_aops
= {
2288 .readpage
= ntfs_readpage
, /* Fill page with data. */
2289 .sync_page
= block_sync_page
, /* Currently, just unplugs the
2290 disk request queue. */
2292 .writepage
= ntfs_writepage
, /* Write dirty page to disk. */
2293 .prepare_write
= ntfs_prepare_write
, /* Prepare page and buffers
2294 ready to receive data. */
2295 .commit_write
= ntfs_commit_write
, /* Commit received data. */
2296 #endif /* NTFS_RW */
2300 * ntfs_mst_aops - general address space operations for mst protecteed inodes
2303 struct address_space_operations ntfs_mst_aops
= {
2304 .readpage
= ntfs_readpage
, /* Fill page with data. */
2305 .sync_page
= block_sync_page
, /* Currently, just unplugs the
2306 disk request queue. */
2308 .writepage
= ntfs_writepage
, /* Write dirty page to disk. */
2309 .set_page_dirty
= __set_page_dirty_nobuffers
, /* Set the page dirty
2310 without touching the buffers
2311 belonging to the page. */
2312 #endif /* NTFS_RW */
2318 * mark_ntfs_record_dirty - mark an ntfs record dirty
2319 * @page: page containing the ntfs record to mark dirty
2320 * @ofs: byte offset within @page at which the ntfs record begins
2322 * Set the buffers and the page in which the ntfs record is located dirty.
2324 * The latter also marks the vfs inode the ntfs record belongs to dirty
2325 * (I_DIRTY_PAGES only).
2327 * If the page does not have buffers, we create them and set them uptodate.
2328 * The page may not be locked which is why we need to handle the buffers under
2329 * the mapping->private_lock. Once the buffers are marked dirty we no longer
2330 * need the lock since try_to_free_buffers() does not free dirty buffers.
2332 void mark_ntfs_record_dirty(struct page
*page
, const unsigned int ofs
) {
2333 struct address_space
*mapping
= page
->mapping
;
2334 ntfs_inode
*ni
= NTFS_I(mapping
->host
);
2335 struct buffer_head
*bh
, *head
, *buffers_to_free
= NULL
;
2336 unsigned int end
, bh_size
, bh_ofs
;
2338 BUG_ON(!PageUptodate(page
));
2339 end
= ofs
+ ni
->itype
.index
.block_size
;
2340 bh_size
= 1 << VFS_I(ni
)->i_blkbits
;
2341 spin_lock(&mapping
->private_lock
);
2342 if (unlikely(!page_has_buffers(page
))) {
2343 spin_unlock(&mapping
->private_lock
);
2344 bh
= head
= alloc_page_buffers(page
, bh_size
, 1);
2345 spin_lock(&mapping
->private_lock
);
2346 if (likely(!page_has_buffers(page
))) {
2347 struct buffer_head
*tail
;
2350 set_buffer_uptodate(bh
);
2352 bh
= bh
->b_this_page
;
2354 tail
->b_this_page
= head
;
2355 attach_page_buffers(page
, head
);
2357 buffers_to_free
= bh
;
2359 bh
= head
= page_buffers(page
);
2361 bh_ofs
= bh_offset(bh
);
2362 if (bh_ofs
+ bh_size
<= ofs
)
2364 if (unlikely(bh_ofs
>= end
))
2366 set_buffer_dirty(bh
);
2367 } while ((bh
= bh
->b_this_page
) != head
);
2368 spin_unlock(&mapping
->private_lock
);
2369 __set_page_dirty_nobuffers(page
);
2370 if (unlikely(buffers_to_free
)) {
2372 bh
= buffers_to_free
->b_this_page
;
2373 free_buffer_head(buffers_to_free
);
2374 buffers_to_free
= bh
;
2375 } while (buffers_to_free
);
2379 #endif /* NTFS_RW */