litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Linus Torvalds <torvalds@ppc970.osdl.org>	2005-04-16 18:20:36 -0400
committer	Linus Torvalds <torvalds@ppc970.osdl.org>	2005-04-16 18:20:36 -0400
commit	1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree	0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/eisa/Makefile

Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!

Diffstat (limited to 'drivers/eisa/Makefile')

-rw-r--r--

drivers/eisa/Makefile

1 files changed, 21 insertions, 0 deletions


diff --git a/drivers/eisa/Makefile b/drivers/eisa/Makefile new file mode 100644 index 000000000000..70abf93fe6b0 --- /dev/null +++ b/drivers/eisa/Makefile
@@ -0,0 +1,21 @@
	1	# Makefile for the Linux device tree
	2
	3	obj-$(CONFIG_EISA) += eisa-bus.o
	4	obj-${CONFIG_EISA_PCI_EISA} += pci_eisa.o
	5
	6	# virtual_root.o should be the last EISA root device to initialize,
	7	# so leave it at the end of the list.
	8	obj-${CONFIG_EISA_VIRTUAL_ROOT} += virtual_root.o
	9
	10
	11	# Ugly hack to get DEVICE_NAME_SIZE value...
	12	DEVICE_NAME_SIZE =$(shell awk '$$1=="\#define" && $$2=="DEVICE_NAME_SIZE" {print $$3-1}' $(srctree)/include/linux/device.h)
	13
	14	$(obj)/eisa-bus.o: $(obj)/devlist.h
	15
	16	quiet_cmd_eisaid = GEN $@
	17	cmd_eisaid = sed -e '/^\#/D' -e 's/^$[[:alnum:]]\{7\}$ \+"$[^"]\{1,$(DEVICE_NAME_SIZE)\}$.*"/EISA_DEVINFO ("\1", "\2"),/' $< > $@
	18
	19	clean-files := devlist.h
	20	$(obj)/devlist.h: $(src)/eisa.ids include/linux/device.h
	21	$(call cmd,eisaid)

/* * file.c - NTFS kernel file operations. Part of the Linux-NTFS project. * * Copyright (c) 2001-2006 Anton Altaparmakov * * This program/include file is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program/include file is distributed in the hope that it will be * useful, but WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program (in the main directory of the Linux-NTFS * distribution in the file COPYING); if not, write to the Free Software * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include <linux/buffer_head.h> #include <linux/pagemap.h> #include <linux/pagevec.h> #include <linux/sched.h> #include <linux/swap.h> #include <linux/uio.h> #include <linux/writeback.h> #include <asm/page.h> #include <asm/uaccess.h> #include "attrib.h" #include "bitmap.h" #include "inode.h" #include "debug.h" #include "lcnalloc.h" #include "malloc.h" #include "mft.h" #include "ntfs.h" /** * ntfs_file_open - called when an inode is about to be opened * @vi: inode to be opened * @filp: file structure describing the inode * * Limit file size to the page cache limit on architectures where unsigned long * is 32-bits. This is the most we can do for now without overflowing the page * cache page index. Doing it this way means we don't run into problems because * of existing too large files. It would be better to allow the user to read * the beginning of the file but I doubt very much anyone is going to hit this * check on a 32-bit architecture, so there is no point in adding the extra * complexity required to support this. * * On 64-bit architectures, the check is hopefully optimized away by the * compiler. * * After the check passes, just call generic_file_open() to do its work. */ static int ntfs_file_open(struct inode *vi, struct file *filp) { if (sizeof(unsigned long) < 8) { if (i_size_read(vi) > MAX_LFS_FILESIZE) return -EFBIG; } return generic_file_open(vi, filp); } #ifdef NTFS_RW /** * ntfs_attr_extend_initialized - extend the initialized size of an attribute * @ni: ntfs inode of the attribute to extend * @new_init_size: requested new initialized size in bytes * @cached_page: store any allocated but unused page here * @lru_pvec: lru-buffering pagevec of the caller * * Extend the initialized size of an attribute described by the ntfs inode @ni * to @new_init_size bytes. This involves zeroing any non-sparse space between * the old initialized size and @new_init_size both in the page cache and on * disk (if relevant complete pages are already uptodate in the page cache then * these are simply marked dirty). * * As a side-effect, the file size (vfs inode->i_size) may be incremented as, * in the resident attribute case, it is tied to the initialized size and, in * the non-resident attribute case, it may not fall below the initialized size. * * Note that if the attribute is resident, we do not need to touch the page * cache at all. This is because if the page cache page is not uptodate we * bring it uptodate later, when doing the write to the mft record since we * then already have the page mapped. And if the page is uptodate, the * non-initialized region will already have been zeroed when the page was * brought uptodate and the region may in fact already have been overwritten * with new data via mmap() based writes, so we cannot just zero it. And since * POSIX specifies that the behaviour of resizing a file whilst it is mmap()ped * is unspecified, we choose not to do zeroing and thus we do not need to touch * the page at all. For a more detailed explanation see ntfs_truncate() in * fs/ntfs/inode.c. * * @cached_page and @lru_pvec are just optimizations for dealing with multiple * pages. * * Return 0 on success and -errno on error. In the case that an error is * encountered it is possible that the initialized size will already have been * incremented some way towards @new_init_size but it is guaranteed that if * this is the case, the necessary zeroing will also have happened and that all * metadata is self-consistent. * * Locking: i_mutex on the vfs inode corrseponsind to the ntfs inode @ni must be * held by the caller. */ static int ntfs_attr_extend_initialized(ntfs_inode *ni, const s64 new_init_size, struct page **cached_page, struct pagevec *lru_pvec) { s64 old_init_size; loff_t old_i_size; pgoff_t index, end_index; unsigned long flags; struct inode *vi = VFS_I(ni); ntfs_inode *base_ni; MFT_RECORD *m = NULL; ATTR_RECORD *a; ntfs_attr_search_ctx *ctx = NULL; struct address_space *mapping; struct page *page = NULL; u8 *kattr; int err; u32 attr_len; read_lock_irqsave(&ni->size_lock, flags); old_init_size = ni->initialized_size; old_i_size = i_size_read(vi); BUG_ON(new_init_size > ni->allocated_size); read_unlock_irqrestore(&ni->size_lock, flags); ntfs_debug("Entering for i_ino 0x%lx, attribute type 0x%x, " "old_initialized_size 0x%llx, " "new_initialized_size 0x%llx, i_size 0x%llx.", vi->i_ino, (unsigned)le32_to_cpu(ni->type), (unsigned long long)old_init_size, (unsigned long long)new_init_size, old_i_size); if (!NInoAttr(ni)) base_ni = ni; else base_ni = ni->ext.base_ntfs_ino; /* Use goto to reduce indentation and we need the label below anyway. */ if (NInoNonResident(ni)) goto do_non_resident_extend; BUG_ON(old_init_size != old_i_size); m = map_mft_record(base_ni); if (IS_ERR(m)) { err = PTR_ERR(m); m = NULL; goto err_out; } ctx = ntfs_attr_get_search_ctx(base_ni, m); if (unlikely(!ctx)) { err = -ENOMEM; goto err_out; } err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, 0, NULL, 0, ctx); if (unlikely(err)) { if (err == -ENOENT) err = -EIO; goto err_out; } m = ctx->mrec; a = ctx->attr; BUG_ON(a->non_resident); /* The total length of the attribute value. */ attr_len = le32_to_cpu(a->data.resident.value_length); BUG_ON(old_i_size != (loff_t)attr_len); /* * Do the zeroing in the mft record and update the attribute size in * the mft record. */ kattr = (u8*)a + le16_to_cpu(a->data.resident.value_offset); memset(kattr + attr_len, 0, new_init_size - attr_len); a->data.resident.value_length = cpu_to_le32((u32)new_init_size); /* Finally, update the sizes in the vfs and ntfs inodes. */ write_lock_irqsave(&ni->size_lock, flags); i_size_write(vi, new_init_size); ni->initialized_size = new_init_size; write_unlock_irqrestore(&ni->size_lock, flags); goto done; do_non_resident_extend: /* * If the new initialized size @new_init_size exceeds the current file * size (vfs inode->i_size), we need to extend the file size to the * new initialized size. */ if (new_init_size > old_i_size) { m = map_mft_record(base_ni); if (IS_ERR(m)) { err = PTR_ERR(m); m = NULL; goto err_out; } ctx = ntfs_attr_get_search_ctx(base_ni, m); if (unlikely(!ctx)) { err = -ENOMEM; goto err_out; } err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, 0, NULL, 0, ctx); if (unlikely(err)) { if (err == -ENOENT) err = -EIO; goto err_out; } m = ctx->mrec; a = ctx->attr; BUG_ON(!a->non_resident); BUG_ON(old_i_size != (loff_t) sle64_to_cpu(a->data.non_resident.data_size)); a->data.non_resident.data_size = cpu_to_sle64(new_init_size); flush_dcache_mft_record_page(ctx->ntfs_ino); mark_mft_record_dirty(ctx->ntfs_ino); /* Update the file size in the vfs inode. */ i_size_write(vi, new_init_size); ntfs_attr_put_search_ctx(ctx); ctx = NULL; unmap_mft_record(base_ni); m = NULL; } mapping = vi->i_mapping; index = old_init_size >> PAGE_CACHE_SHIFT; end_index = (new_init_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; do { /* * Read the page. If the page is not present, this will zero * the uninitialized regions for us. */ page = read_mapping_page(mapping, index, NULL); if (IS_ERR(page)) { err = PTR_ERR(page); goto init_err_out; } wait_on_page_locked(page); if (unlikely(!PageUptodate(page) || PageError(page))) { page_cache_release(page); err = -EIO; goto init_err_out; } /* * Update the initialized size in the ntfs inode. This is * enough to make ntfs_writepage() work. */ write_lock_irqsave(&ni->size_lock, flags); ni->initialized_size = (s64)(index + 1) << PAGE_CACHE_SHIFT; if (ni->initialized_size > new_init_size) ni->initialized_size = new_init_size; write_unlock_irqrestore(&ni->size_lock, flags); /* Set the page dirty so it gets written out. */ set_page_dirty(page); page_cache_release(page); /* * Play nice with the vm and the rest of the system. This is * very much needed as we can potentially be modifying the * initialised size from a very small value to a really huge * value, e.g. * f = open(somefile, O_TRUNC); * truncate(f, 10GiB); * seek(f, 10GiB); * write(f, 1); * And this would mean we would be marking dirty hundreds of * thousands of pages or as in the above example more than * two and a half million pages! * * TODO: For sparse pages could optimize this workload by using * the FsMisc / MiscFs page bit as a "PageIsSparse" bit. This * would be set in readpage for sparse pages and here we would * not need to mark dirty any pages which have this bit set. * The only caveat is that we have to clear the bit everywhere * where we allocate any clusters that lie in the page or that * contain the page. * * TODO: An even greater optimization would be for us to only * call readpage() on pages which are not in sparse regions as * determined from the runlist. This would greatly reduce the * number of pages we read and make dirty in the case of sparse * files. */ balance_dirty_pages_ratelimited(mapping); cond_resched(); } while (++index < end_index); read_lock_irqsave(&ni->size_lock, flags); BUG_ON(ni->initialized_size != new_init_size); read_unlock_irqrestore(&ni->size_lock, flags); /* Now bring in sync the initialized_size in the mft record. */ m = map_mft_record(base_ni); if (IS_ERR(m)) { err = PTR_ERR(m); m = NULL; goto init_err_out; } ctx = ntfs_attr_get_search_ctx(base_ni, m); if (unlikely(!ctx)) { err = -ENOMEM; goto init_err_out; } err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, 0, NULL, 0, ctx); if (unlikely(err)) { if (err == -ENOENT) err = -EIO; goto init_err_out; } m = ctx->mrec; a = ctx->attr; BUG_ON(!a->non_resident); a->data.non_resident.initialized_size = cpu_to_sle64(new_init_size); done: flush_dcache_mft_record_page(ctx->ntfs_ino); mark_mft_record_dirty(ctx->ntfs_ino); if (ctx) ntfs_attr_put_search_ctx(ctx); if (m) unmap_mft_record(base_ni); ntfs_debug("Done, initialized_size 0x%llx, i_size 0x%llx.", (unsigned long long)new_init_size, i_size_read(vi)); return 0; init_err_out: write_lock_irqsave(&ni->size_lock, flags); ni->initialized_size = old_init_size; write_unlock_irqrestore(&ni->size_lock, flags); err_out: if (ctx) ntfs_attr_put_search_ctx(ctx); if (m) unmap_mft_record(base_ni); ntfs_debug("Failed. Returning error code %i.", err); return err; } /** * ntfs_fault_in_pages_readable - * * Fault a number of userspace pages into pagetables. * * Unlike include/linux/pagemap.h::fault_in_pages_readable(), this one copes * with more than two userspace pages as well as handling the single page case * elegantly. * * If you find this difficult to understand, then think of the while loop being * the following code, except that we do without the integer variable ret: * * do { * ret = __get_user(c, uaddr); * uaddr += PAGE_SIZE; * } while (!ret && uaddr < end); * * Note, the final __get_user() may well run out-of-bounds of the user buffer, * but _not_ out-of-bounds of the page the user buffer belongs to, and since * this is only a read and not a write, and since it is still in the same page, * it should not matter and this makes the code much simpler. */ static inline void ntfs_fault_in_pages_readable(const char __user *uaddr, int bytes) { const char __user *end; volatile char c; /* Set @end to the first byte outside the last page we care about. */ end = (const char __user*)PAGE_ALIGN((ptrdiff_t __user)uaddr + bytes); while (!__get_user(c, uaddr) && (uaddr += PAGE_SIZE, uaddr < end)) ; } /** * ntfs_fault_in_pages_readable_iovec - * * Same as ntfs_fault_in_pages_readable() but operates on an array of iovecs. */ static inline void ntfs_fault_in_pages_readable_iovec(const struct iovec *iov, size_t iov_ofs, int bytes) { do { const char __user *buf; unsigned len; buf = iov->iov_base + iov_ofs; len = iov->iov_len - iov_ofs; if (len > bytes) len = bytes; ntfs_fault_in_pages_readable(buf, len); bytes -= len; iov++; iov_ofs = 0; } while (bytes); } /** * __ntfs_grab_cache_pages - obtain a number of locked pages * @mapping: address space mapping from which to obtain page cache pages * @index: starting index in @mapping at which to begin obtaining pages * @nr_pages: number of page cache pages to obtain * @pages: array of pages in which to return the obtained page cache pages * @cached_page: allocated but as yet unused page * @lru_pvec: lru-buffering pagevec of caller * * Obtain @nr_pages locked page cache pages from the mapping @maping and * starting at index @index. * * If a page is newly created, increment its refcount and add it to the * caller's lru-buffering pagevec @lru_pvec. * * This is the same as mm/filemap.c::__grab_cache_page(), except that @nr_pages * are obtained at once instead of just one page and that 0 is returned on * success and -errno on error. * * Note, the page locks are obtained in ascending page index order. */ static inline int __ntfs_grab_cache_pages(struct address_space *mapping, pgoff_t index, const unsigned nr_pages, struct page **pages, struct page **cached_page, struct pagevec *lru_pvec) { int err, nr; BUG_ON(!nr_pages); err = nr = 0; do { pages[nr] = find_lock_page(mapping, index); if (!pages[nr]) { if (!*cached_page) { *cached_page = page_cache_alloc(mapping); if (unlikely(!*cached_page)) { err = -ENOMEM; goto err_out; } } err = add_to_page_cache(*cached_page, mapping, index, GFP_KERNEL); if (unlikely(err)) { if (err == -EEXIST) continue; goto err_out; } pages[nr] = *cached_page; page_cache_get(*cached_page); if (unlikely(!pagevec_add(lru_pvec, *cached_page))) __pagevec_lru_add(lru_pvec); *cached_page = NULL; } index++; nr++; } while (nr < nr_pages); out: return err; err_out: while (nr > 0) { unlock_page(pages[--nr]); page_cache_release(pages[nr]); } goto out; } static inline int ntfs_submit_bh_for_read(struct buffer_head *bh) { lock_buffer(bh); get_bh(bh); bh->b_end_io = end_buffer_read_sync; return submit_bh(READ, bh); } /** * ntfs_prepare_pages_for_non_resident_write - prepare pages for receiving data * @pages: array of destination pages * @nr_pages: number of pages in @pages * @pos: byte position in file at which the write begins * @bytes: number of bytes to be written * * This is called for non-resident attributes from ntfs_file_buffered_write() * with i_mutex held on the inode (@pages[0]->mapping->host). There are * @nr_pages pages in @pages which are locked but not kmap()ped. The source * data has not yet been copied into the @pages. * * Need to fill any holes with actual clusters, allocate buffers if necessary, * ensure all the buffers are mapped, and bring uptodate any buffers that are * only partially being written to. * * If @nr_pages is greater than one, we are guaranteed that the cluster size is * greater than PAGE_CACHE_SIZE, that all pages in @pages are entirely inside * the same cluster and that they are the entirety of that cluster, and that * the cluster is sparse, i.e. we need to allocate a cluster to fill the hole. * * i_size is not to be modified yet. * * Return 0 on success or -errno on error. */ static int ntfs_prepare_pages_for_non_resident_write(struct page **pages, unsigned nr_pages, s64 pos, size_t bytes) { VCN vcn, highest_vcn = 0, cpos, cend, bh_cpos, bh_cend; LCN lcn; s64 bh_pos, vcn_len, end, initialized_size; sector_t lcn_block; struct page *page; struct inode *vi; ntfs_inode *ni, *base_ni = NULL; ntfs_volume *vol; runlist_element *rl, *rl2; struct buffer_head *bh, *head, *wait[2], **wait_bh = wait; ntfs_attr_search_ctx *ctx = NULL; MFT_RECORD *m = NULL; ATTR_RECORD *a = NULL; unsigned long flags; u32 attr_rec_len = 0; unsigned blocksize, u; int err, mp_size; bool rl_write_locked, was_hole, is_retry; unsigned char blocksize_bits; struct { u8 runlist_merged:1; u8 mft_attr_mapped:1; u8 mp_rebuilt:1; u8 attr_switched:1; } status = { 0, 0, 0, 0 }; BUG_ON(!nr_pages); BUG_ON(!pages); BUG_ON(!*pages); vi = pages[0]->mapping->host; ni = NTFS_I(vi); vol = ni->vol; ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, start page " "index 0x%lx, nr_pages 0x%x, pos 0x%llx, bytes 0x%zx.", vi->i_ino, ni->type, pages[0]->index, nr_pages, (long long)pos, bytes); blocksize = vol->sb->s_blocksize; blocksize_bits = vol->sb->s_blocksize_bits; u = 0; do { struct page *page = pages[u]; /* * create_empty_buffers() will create uptodate/dirty buffers if * the page is uptodate/dirty. */ if (!page_has_buffers(page)) { create_empty_buffers(page, blocksize, 0); if (unlikely(!page_has_buffers(page))) return -ENOMEM; } } while (++u < nr_pages); rl_write_locked = false; rl = NULL; err = 0; vcn = lcn = -1; vcn_len = 0; lcn_block = -1; was_hole = false; cpos = pos >> vol->cluster_size_bits; end = pos + bytes; cend = (end + vol->cluster_size - 1) >> vol->cluster_size_bits; /* * Loop over each page and for each page over each buffer. Use goto to * reduce indentation. */ u = 0; do_next_page: page = pages[u]; bh_pos = (s64)page->index << PAGE_CACHE_SHIFT; bh = head = page_buffers(page); do { VCN cdelta; s64 bh_end; unsigned bh_cofs; /* Clear buffer_new on all buffers to reinitialise state. */ if (buffer_new(bh)) clear_buffer_new(bh); bh_end = bh_pos + blocksize; bh_cpos = bh_pos >> vol->cluster_size_bits; bh_cofs = bh_pos & vol->cluster_size_mask; if (buffer_mapped(bh)) { /* * The buffer is already mapped. If it is uptodate, * ignore it. */ if (buffer_uptodate(bh)) continue; /* * The buffer is not uptodate. If the page is uptodate * set the buffer uptodate and otherwise ignore it. */ if (PageUptodate(page)) { set_buffer_uptodate(bh); continue; } /* * Neither the page nor the buffer are uptodate. If * the buffer is only partially being written to, we * need to read it in before the write, i.e. now. */ if ((bh_pos < pos && bh_end > pos) || (bh_pos < end && bh_end > end)) { /* * If the buffer is fully or partially within * the initialized size, do an actual read. * Otherwise, simply zero the buffer. */ read_lock_irqsave(&ni->size_lock, flags); initialized_size = ni->initialized_size; read_unlock_irqrestore(&ni->size_lock, flags); if (bh_pos < initialized_size) { ntfs_submit_bh_for_read(bh); *wait_bh++ = bh; } else { u8 *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + bh_offset(bh), 0, blocksize); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); set_buffer_uptodate(bh); } } continue; } /* Unmapped buffer. Need to map it. */ bh->b_bdev = vol->sb->s_bdev; /* * If the current buffer is in the same clusters as the map * cache, there is no need to check the runlist again. The * map cache is made up of @vcn, which is the first cached file * cluster, @vcn_len which is the number of cached file * clusters, @lcn is the device cluster corresponding to @vcn, * and @lcn_block is the block number corresponding to @lcn. */ cdelta = bh_cpos - vcn; if (likely(!cdelta || (cdelta > 0 && cdelta < vcn_len))) { map_buffer_cached: BUG_ON(lcn < 0); bh->b_blocknr = lcn_block + (cdelta << (vol->cluster_size_bits - blocksize_bits)) + (bh_cofs >> blocksize_bits); set_buffer_mapped(bh); /* * If the page is uptodate so is the buffer. If the * buffer is fully outside the write, we ignore it if * it was already allocated and we mark it dirty so it * gets written out if we allocated it. On the other * hand, if we allocated the buffer but we are not * marking it dirty we set buffer_new so we can do * error recovery. */ if (PageUptodate(page)) { if (!buffer_uptodate(bh)) set_buffer_uptodate(bh); if (unlikely(was_hole)) { /* We allocated the buffer. */ unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr); if (bh_end <= pos || bh_pos >= end) mark_buffer_dirty(bh); else set_buffer_new(bh); } continue; } /* Page is _not_ uptodate. */ if (likely(!was_hole)) { /* * Buffer was already allocated. If it is not * uptodate and is only partially being written * to, we need to read it in before the write, * i.e. now. */ if (!buffer_uptodate(bh) && bh_pos < end && bh_end > pos && (bh_pos < pos || bh_end > end)) { /* * If the buffer is fully or partially * within the initialized size, do an * actual read. Otherwise, simply zero * the buffer. */ read_lock_irqsave(&ni->size_lock, flags); initialized_size = ni->initialized_size; read_unlock_irqrestore(&ni->size_lock, flags); if (bh_pos < initialized_size) { ntfs_submit_bh_for_read(bh); *wait_bh++ = bh; } else { u8 *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + bh_offset(bh), 0, blocksize); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); set_buffer_uptodate(bh); } } continue; } /* We allocated the buffer. */ unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr); /* * If the buffer is fully outside the write, zero it, * set it uptodate, and mark it dirty so it gets * written out. If it is partially being written to, * zero region surrounding the write but leave it to * commit write to do anything else. Finally, if the * buffer is fully being overwritten, do nothing. */ if (bh_end <= pos || bh_pos >= end) { if (!buffer_uptodate(bh)) { u8 *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + bh_offset(bh), 0, blocksize); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); set_buffer_uptodate(bh); } mark_buffer_dirty(bh); continue; } set_buffer_new(bh); if (!buffer_uptodate(bh) && (bh_pos < pos || bh_end > end)) { u8 *kaddr; unsigned pofs; kaddr = kmap_atomic(page, KM_USER0); if (bh_pos < pos) { pofs = bh_pos & ~PAGE_CACHE_MASK; memset(kaddr + pofs, 0, pos - bh_pos); } if (bh_end > end) { pofs = end & ~PAGE_CACHE_MASK; memset(kaddr + pofs, 0, bh_end - end); } kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); } continue; } /* * Slow path: this is the first buffer in the cluster. If it * is outside allocated size and is not uptodate, zero it and * set it uptodate. */ read_lock_irqsave(&ni->size_lock, flags); initialized_size = ni->allocated_size; read_unlock_irqrestore(&ni->size_lock, flags); if (bh_pos > initialized_size) { if (PageUptodate(page)) { if (!buffer_uptodate(bh)) set_buffer_uptodate(bh); } else if (!buffer_uptodate(bh)) { u8 *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + bh_offset(bh), 0, blocksize); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); set_buffer_uptodate(bh); } continue; } is_retry = false; if (!rl) { down_read(&ni->runlist.lock); retry_remap: rl = ni->runlist.rl; } if (likely(rl != NULL)) { /* Seek to element containing target cluster. */ while (rl->length && rl[1].vcn <= bh_cpos) rl++; lcn = ntfs_rl_vcn_to_lcn(rl, bh_cpos); if (likely(lcn >= 0)) { /* * Successful remap, setup the map cache and * use that to deal with the buffer. */ was_hole = false; vcn = bh_cpos; vcn_len = rl[1].vcn - vcn; lcn_block = lcn << (vol->cluster_size_bits - blocksize_bits); cdelta = 0; /* * If the number of remaining clusters touched * by the write is smaller or equal to the * number of cached clusters, unlock the * runlist as the map cache will be used from * now on. */ if (likely(vcn + vcn_len >= cend)) { if (rl_write_locked) { up_write(&ni->runlist.lock); rl_write_locked = false; } else up_read(&ni->runlist.lock); rl = NULL; } goto map_buffer_cached; } } else lcn = LCN_RL_NOT_MAPPED; /* * If it is not a hole and not out of bounds, the runlist is * probably unmapped so try to map it now. */ if (unlikely(lcn != LCN_HOLE && lcn != LCN_ENOENT)) { if (likely(!is_retry && lcn == LCN_RL_NOT_MAPPED)) { /* Attempt to map runlist. */ if (!rl_write_locked) { /* * We need the runlist locked for * writing, so if it is locked for * reading relock it now and retry in * case it changed whilst we dropped * the lock. */ up_read(&ni->runlist.lock); down_write(&ni->runlist.lock); rl_write_locked = true; goto retry_remap; } err = ntfs_map_runlist_nolock(ni, bh_cpos, NULL); if (likely(!err)) { is_retry = true; goto retry_remap; } /* * If @vcn is out of bounds, pretend @lcn is * LCN_ENOENT. As long as the buffer is out * of bounds this will work fine. */ if (err == -ENOENT) { lcn = LCN_ENOENT; err = 0; goto rl_not_mapped_enoent; } } else err = -EIO; /* Failed to map the buffer, even after retrying. */ bh->b_blocknr = -1; ntfs_error(vol->sb, "Failed to write to inode 0x%lx, " "attribute type 0x%x, vcn 0x%llx, " "vcn offset 0x%x, because its " "location on disk could not be " "determined%s (error code %i).", ni->mft_no, ni->type, (unsigned long long)bh_cpos, (unsigned)bh_pos & vol->cluster_size_mask, is_retry ? " even after retrying" : "", err); break; } rl_not_mapped_enoent: /* * The buffer is in a hole or out of bounds. We need to fill * the hole, unless the buffer is in a cluster which is not * touched by the write, in which case we just leave the buffer * unmapped. This can only happen when the cluster size is * less than the page cache size. */ if (unlikely(vol->cluster_size < PAGE_CACHE_SIZE)) { bh_cend = (bh_end + vol->cluster_size - 1) >> vol->cluster_size_bits; if ((bh_cend <= cpos || bh_cpos >= cend)) { bh->b_blocknr = -1; /* * If the buffer is uptodate we skip it. If it * is not but the page is uptodate, we can set * the buffer uptodate. If the page is not * uptodate, we can clear the buffer and set it * uptodate. Whether this is worthwhile is * debatable and this could be removed. */ if (PageUptodate(page)) { if (!buffer_uptodate(bh)) set_buffer_uptodate(bh); } else if (!buffer_uptodate(bh)) { u8 *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + bh_offset(bh), 0, blocksize); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); set_buffer_uptodate(bh); } continue; } } /* * Out of bounds buffer is invalid if it was not really out of * bounds. */ BUG_ON(lcn != LCN_HOLE); /* * We need the runlist locked for writing, so if it is locked * for reading relock it now and retry in case it changed * whilst we dropped the lock. */ BUG_ON(!rl); if (!rl_write_locked) { up_read(&ni->runlist.lock); down_write(&ni->runlist.lock); rl_write_locked = true; goto retry_remap; } /* Find the previous last allocated cluster. */ BUG_ON(rl->lcn != LCN_HOLE); lcn = -1; rl2 = rl; while (--rl2 >= ni->runlist.rl) { if (rl2->lcn >= 0) { lcn = rl2->lcn + rl2->length; break; } } rl2 = ntfs_cluster_alloc(vol, bh_cpos, 1, lcn, DATA_ZONE, false); if (IS_ERR(rl2)) { err = PTR_ERR(rl2); ntfs_debug("Failed to allocate cluster, error code %i.", err); break; } lcn = rl2->lcn; rl = ntfs_runlists_merge(ni->runlist.rl, rl2); if (IS_ERR(rl)) { err = PTR_ERR(rl); if (err != -ENOMEM) err = -EIO; if (ntfs_cluster_free_from_rl(vol, rl2)) { ntfs_error(vol->sb, "Failed to release " "allocated cluster in error " "code path. Run chkdsk to " "recover the lost cluster."); NVolSetErrors(vol); } ntfs_free(rl2); break; } ni->runlist.rl = rl; status.runlist_merged = 1; ntfs_debug("Allocated cluster, lcn 0x%llx.", (unsigned long long)lcn); /* Map and lock the mft record and get the attribute record. */ if (!NInoAttr(ni)) base_ni = ni; else base_ni = ni->ext.base_ntfs_ino; m = map_mft_record(base_ni); if (IS_ERR(m)) { err = PTR_ERR(m); break; } ctx = ntfs_attr_get_search_ctx(base_ni, m); if (unlikely(!ctx)) { err = -ENOMEM; unmap_mft_record(base_ni); break; } status.mft_attr_mapped = 1; err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, bh_cpos, NULL, 0, ctx); if (unlikely(err)) { if (err == -ENOENT) err = -EIO; break; } m = ctx->mrec; a = ctx->attr; /* * Find the runlist element with which the attribute extent * starts. Note, we cannot use the _attr_ version because we * have mapped the mft record. That is ok because we know the * runlist fragment must be mapped already to have ever gotten * here, so we can just use the _rl_ version. */ vcn = sle64_to_cpu(a->data.non_resident.lowest_vcn); rl2 = ntfs_rl_find_vcn_nolock(rl, vcn); BUG_ON(!rl2); BUG_ON(!rl2->length); BUG_ON(rl2->lcn < LCN_HOLE); highest_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn); /* * If @highest_vcn is zero, calculate the real highest_vcn * (which can really be zero). */ if (!highest_vcn) highest_vcn = (sle64_to_cpu( a->data.non_resident.allocated_size) >> vol->cluster_size_bits) - 1; /* * Determine the size of the mapping pairs array for the new * extent, i.e. the old extent with the hole filled. */ mp_size = ntfs_get_size_for_mapping_pairs(vol, rl2, vcn, highest_vcn); if (unlikely(mp_size <= 0)) { if (!(err = mp_size)) err = -EIO; ntfs_debug("Failed to get size for mapping pairs " "array, error code %i.", err); break; } /* * Resize the attribute record to fit the new mapping pairs * array. */ attr_rec_len = le32_to_cpu(a->length); err = ntfs_attr_record_resize(m, a, mp_size + le16_to_cpu( a->data.non_resident.mapping_pairs_offset)); if (unlikely(err)) { BUG_ON(err != -ENOSPC); // TODO: Deal with this by using the current attribute // and fill it with as much of the mapping pairs // array as possible. Then loop over each attribute // extent rewriting the mapping pairs arrays as we go // along and if when we reach the end we have not // enough space, try to resize the last attribute // extent and if even that fails, add a new attribute // extent. // We could also try to resize at each step in the hope // that we will not need to rewrite every single extent. // Note, we may need to decompress some extents to fill // the runlist as we are walking the extents... ntfs_error(vol->sb, "Not enough space in the mft " "record for the extended attribute " "record. This case is not " "implemented yet."); err = -EOPNOTSUPP; break ; } status.mp_rebuilt = 1; /* * Generate the mapping pairs array directly into the attribute * record. */ err = ntfs_mapping_pairs_build(vol, (u8*)a + le16_to_cpu( a->data.non_resident.mapping_pairs_offset), mp_size, rl2, vcn, highest_vcn, NULL); if (unlikely(err)) { ntfs_error(vol->sb, "Cannot fill hole in inode 0x%lx, " "attribute type 0x%x, because building " "the mapping pairs failed with error " "code %i.", vi->i_ino, (unsigned)le32_to_cpu(ni->type), err); err = -EIO; break; } /* Update the highest_vcn but only if it was not set. */ if (unlikely(!a->data.non_resident.highest_vcn)) a->data.non_resident.highest_vcn = cpu_to_sle64(highest_vcn); /* * If the attribute is sparse/compressed, update the compressed * size in the ntfs_inode structure and the attribute record. */ if (likely(NInoSparse(ni) || NInoCompressed(ni))) { /* * If we are not in the first attribute extent, switch * to it, but first ensure the changes will make it to * disk later. */ if (a->data.non_resident.lowest_vcn) { flush_dcache_mft_record_page(ctx->ntfs_ino); mark_mft_record_dirty(ctx->ntfs_ino); ntfs_attr_reinit_search_ctx(ctx); err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, 0, NULL, 0, ctx); if (unlikely(err)) { status.attr_switched = 1; break; } /* @m is not used any more so do not set it. */ a = ctx->attr; } write_lock_irqsave(&ni->size_lock, flags); ni->itype.compressed.size += vol->cluster_size; a->data.non_resident.compressed_size = cpu_to_sle64(ni->itype.compressed.size); write_unlock_irqrestore(&ni->size_lock, flags); } /* Ensure the changes make it to disk. */ flush_dcache_mft_record_page(ctx->ntfs_ino); mark_mft_record_dirty(ctx->ntfs_ino); ntfs_attr_put_search_ctx(ctx); unmap_mft_record(base_ni); /* Successfully filled the hole. */ status.runlist_merged = 0; status.mft_attr_mapped = 0; status.mp_rebuilt = 0; /* Setup the map cache and use that to deal with the buffer. */ was_hole = true; vcn = bh_cpos; vcn_len = 1; lcn_block = lcn << (vol->cluster_size_bits - blocksize_bits); cdelta = 0; /* * If the number of remaining clusters in the @pages is smaller * or equal to the number of cached clusters, unlock the * runlist as the map cache will be used from now on. */ if (likely(vcn + vcn_len >= cend)) { up_write(&ni->runlist.lock); rl_write_locked = false; rl = NULL; } goto map_buffer_cached; } while (bh_pos += blocksize, (bh = bh->b_this_page) != head); /* If there are no errors, do the next page. */ if (likely(!err && ++u < nr_pages)) goto do_next_page; /* If there are no errors, release the runlist lock if we took it. */ if (likely(!err)) { if (unlikely(rl_write_locked)) { up_write(&ni->runlist.lock); rl_write_locked = false; } else if (unlikely(rl)) up_read(&ni->runlist.lock); rl = NULL; } /* If we issued read requests, let them complete. */ read_lock_irqsave(&ni->size_lock, flags); initialized_size = ni->initialized_size; read_unlock_irqrestore(&ni->size_lock, flags); while (wait_bh > wait) { bh = *--wait_bh; wait_on_buffer(bh); if (likely(buffer_uptodate(bh))) { page = bh->b_page; bh_pos = ((s64)page->index << PAGE_CACHE_SHIFT) + bh_offset(bh); /* * If the buffer overflows the initialized size, need * to zero the overflowing region. */ if (unlikely(bh_pos + blocksize > initialized_size)) { u8 *kaddr; int ofs = 0; if (likely(bh_pos < initialized_size)) ofs = initialized_size - bh_pos; kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + bh_offset(bh) + ofs, 0, blocksize - ofs); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); } } else /* if (unlikely(!buffer_uptodate(bh))) */ err = -EIO; } if (likely(!err)) { /* Clear buffer_new on all buffers. */ u = 0; do { bh = head = page_buffers(pages[u]); do { if (buffer_new(bh)) clear_buffer_new(bh); } while ((bh = bh->b_this_page) != head); } while (++u < nr_pages); ntfs_debug("Done."); return err; } if (status.attr_switched) { /* Get back to the attribute extent we modified. */ ntfs_attr_reinit_search_ctx(ctx); if (ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, bh_cpos, NULL, 0, ctx)) { ntfs_error(vol->sb, "Failed to find required " "attribute extent of attribute in " "error code path. Run chkdsk to " "recover."); write_lock_irqsave(&ni->size_lock, flags); ni->itype.compressed.size += vol->cluster_size; write_unlock_irqrestore(&ni->size_lock, flags); flush_dcache_mft_record_page(ctx->ntfs_ino); mark_mft_record_dirty(ctx->ntfs_ino); /* * The only thing that is now wrong is the compressed * size of the base attribute extent which chkdsk * should be able to fix. */ NVolSetErrors(vol); } else { m = ctx->mrec; a = ctx->attr; status.attr_switched = 0; } } /* * If the runlist has been modified, need to restore it by punching a * hole into it and we then need to deallocate the on-disk cluster as * well. Note, we only modify the runlist if we are able to generate a * new mapping pairs array, i.e. only when the mapped attribute extent * is not switched. */ if (status.runlist_merged && !status.attr_switched) { BUG_ON(!rl_write_locked); /* Make the file cluster we allocated sparse in the runlist. */ if (ntfs_rl_punch_nolock(vol, &ni->runlist, bh_cpos, 1)) { ntfs_error(vol->sb, "Failed to punch hole into " "attribute runlist in error code " "path. Run chkdsk to recover the " "lost cluster."); NVolSetErrors(vol); } else /* if (success) */ { status.runlist_merged = 0; /* * Deallocate the on-disk cluster we allocated but only * if we succeeded in punching its vcn out of the * runlist. */ down_write(&vol->lcnbmp_lock); if (ntfs_bitmap_clear_bit(vol->lcnbmp_ino, lcn)) { ntfs_error(vol->sb, "Failed to release " "allocated cluster in error " "code path. Run chkdsk to " "recover the lost cluster."); NVolSetErrors(vol); } up_write(&vol->lcnbmp_lock); } } /* * Resize the attribute record to its old size and rebuild the mapping * pairs array. Note, we only can do this if the runlist has been * restored to its old state which also implies that the mapped * attribute extent is not switched. */ if (status.mp_rebuilt && !status.runlist_merged) { if (ntfs_attr_record_resize(m, a, attr_rec_len)) { ntfs_error(vol->sb, "Failed to restore attribute " "record in error code path. Run " "chkdsk to recover."); NVolSetErrors(vol); } else /* if (success) */ { if (ntfs_mapping_pairs_build(vol, (u8*)a + le16_to_cpu(a->data.non_resident. mapping_pairs_offset), attr_rec_len - le16_to_cpu(a->data.non_resident. mapping_pairs_offset), ni->runlist.rl, vcn, highest_vcn, NULL)) { ntfs_error(vol->sb, "Failed to restore " "mapping pairs array in error " "code path. Run chkdsk to " "recover."); NVolSetErrors(vol); } flush_dcache_mft_record_page(ctx->ntfs_ino); mark_mft_record_dirty(ctx->ntfs_ino); } } /* Release the mft record and the attribute. */ if (status.mft_attr_mapped) { ntfs_attr_put_search_ctx(ctx); unmap_mft_record(base_ni); } /* Release the runlist lock. */ if (rl_write_locked) up_write(&ni->runlist.lock); else if (rl) up_read(&ni->runlist.lock); /* * Zero out any newly allocated blocks to avoid exposing stale data. * If BH_New is set, we know that the block was newly allocated above * and that it has not been fully zeroed and marked dirty yet. */ nr_pages = u; u = 0; end = bh_cpos << vol->cluster_size_bits; do { page = pages[u]; bh = head = page_buffers(page); do { if (u == nr_pages && ((s64)page->index << PAGE_CACHE_SHIFT) + bh_offset(bh) >= end) break; if (!buffer_new(bh)) continue; clear_buffer_new(bh); if (!buffer_uptodate(bh)) { if (PageUptodate(page)) set_buffer_uptodate(bh); else { u8 *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + bh_offset(bh), 0, blocksize); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); set_buffer_uptodate(bh); } } mark_buffer_dirty(bh); } while ((bh = bh->b_this_page) != head); } while (++u <= nr_pages); ntfs_error(vol->sb, "Failed. Returning error code %i.", err); return err; } /* * Copy as much as we can into the pages and return the number of bytes which * were sucessfully copied. If a fault is encountered then clear the pages * out to (ofs + bytes) and return the number of bytes which were copied. */ static inline size_t ntfs_copy_from_user(struct page **pages, unsigned nr_pages, unsigned ofs, const char __user *buf, size_t bytes) { struct page **last_page = pages + nr_pages; char *kaddr; size_t total = 0; unsigned len; int left; do { len = PAGE_CACHE_SIZE - ofs; if (len > bytes) len = bytes; kaddr = kmap_atomic(*pages, KM_USER0); left = __copy_from_user_inatomic(kaddr + ofs, buf, len); kunmap_atomic(kaddr, KM_USER0); if (unlikely(left)) { /* Do it the slow way. */ kaddr = kmap(*pages); left = __copy_from_user(kaddr + ofs, buf, len); kunmap(*pages); if (unlikely(left)) goto err_out; } total += len; bytes -= len; if (!bytes) break; buf += len; ofs = 0; } while (++pages < last_page); out: return total; err_out: total += len - left; /* Zero the rest of the target like __copy_from_user(). */ while (++pages < last_page) { bytes -= len; if (!bytes) break; len = PAGE_CACHE_SIZE; if (len > bytes) len = bytes; kaddr = kmap_atomic(*pages, KM_USER0); memset(kaddr, 0, len); kunmap_atomic(kaddr, KM_USER0); } goto out; } static size_t __ntfs_copy_from_user_iovec_inatomic(char *vaddr, const struct iovec *iov, size_t iov_ofs, size_t bytes) { size_t total = 0; while (1) { const char __user *buf = iov->iov_base + iov_ofs; unsigned len; size_t left; len = iov->iov_len - iov_ofs; if (len > bytes) len = bytes; left = __copy_from_user_inatomic(vaddr, buf, len); total += len; bytes -= len; vaddr += len; if (unlikely(left)) { total -= left; break; } if (!bytes) break; iov++; iov_ofs = 0; } return total; } static inline void ntfs_set_next_iovec(const struct iovec **iovp, size_t *iov_ofsp, size_t bytes) { const struct iovec *iov = *iovp; size_t iov_ofs = *iov_ofsp; while (bytes) { unsigned len; len = iov->iov_len - iov_ofs; if (len > bytes) len = bytes; bytes -= len; iov_ofs += len; if (iov->iov_len == iov_ofs) { iov++; iov_ofs = 0; } } *iovp = iov; *iov_ofsp = iov_ofs; } /* * This has the same side-effects and return value as ntfs_copy_from_user(). * The difference is that on a fault we need to memset the remainder of the * pages (out to offset + bytes), to emulate ntfs_copy_from_user()'s * single-segment behaviour. * * We call the same helper (__ntfs_copy_from_user_iovec_inatomic()) both * when atomic and when not atomic. This is ok because * __ntfs_copy_from_user_iovec_inatomic() calls __copy_from_user_inatomic() * and it is ok to call this when non-atomic. * Infact, the only difference between __copy_from_user_inatomic() and * __copy_from_user() is that the latter calls might_sleep() and the former * should not zero the tail of the buffer on error. And on many * architectures __copy_from_user_inatomic() is just defined to * __copy_from_user() so it makes no difference at all on those architectures. */ static inline size_t ntfs_copy_from_user_iovec(struct page **pages, unsigned nr_pages, unsigned ofs, const struct iovec **iov, size_t *iov_ofs, size_t bytes) { struct page **last_page = pages + nr_pages; char *kaddr; size_t copied, len, total = 0; do { len = PAGE_CACHE_SIZE - ofs; if (len > bytes) len = bytes; kaddr = kmap_atomic(*pages, KM_USER0); copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs, *iov, *iov_ofs, len); kunmap_atomic(kaddr, KM_USER0); if (unlikely(copied != len)) { /* Do it the slow way. */ kaddr = kmap(*pages); copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs, *iov, *iov_ofs, len); /* * Zero the rest of the target like __copy_from_user(). */ memset(kaddr + ofs + copied, 0, len - copied); kunmap(*pages); if (unlikely(copied != len)) goto err_out; } total += len; bytes -= len; if (!bytes) break; ntfs_set_next_iovec(iov, iov_ofs, len); ofs = 0; } while (++pages < last_page); out: return total; err_out: total += copied; /* Zero the rest of the target like __copy_from_user(). */ while (++pages < last_page) { bytes -= len; if (!bytes) break; len = PAGE_CACHE_SIZE; if (len > bytes) len = bytes; kaddr = kmap_atomic(*pages, KM_USER0); memset(kaddr, 0, len); kunmap_atomic(kaddr, KM_USER0); } goto out; } static inline void ntfs_flush_dcache_pages(struct page **pages, unsigned nr_pages) { BUG_ON(!nr_pages); /* * Warning: Do not do the decrement at the same time as the call to * flush_dcache_page() because it is a NULL macro on i386 and hence the * decrement never happens so the loop never terminates. */ do { --nr_pages; flush_dcache_page(pages[nr_pages]); } while (nr_pages > 0); } /** * ntfs_commit_pages_after_non_resident_write - commit the received data * @pages: array of destination pages * @nr_pages: number of pages in @pages * @pos: byte position in file at which the write begins * @bytes: number of bytes to be written * * See description of ntfs_commit_pages_after_write(), below. */ static inline int ntfs_commit_pages_after_non_resident_write( struct page **pages, const unsigned nr_pages, s64 pos, size_t bytes) { s64 end, initialized_size; struct inode *vi; ntfs_inode *ni, *base_ni; struct buffer_head *bh, *head; ntfs_attr_search_ctx *ctx; MFT_RECORD *m; ATTR_RECORD *a; unsigned long flags; unsigned blocksize, u; int err; vi = pages[0]->mapping->host; ni = NTFS_I(vi); blocksize = vi->i_sb->s_blocksize; end = pos + bytes; u = 0; do { s64 bh_pos; struct page *page; bool partial; page = pages[u]; bh_pos = (s64)page->index << PAGE_CACHE_SHIFT; bh = head = page_buffers(page); partial = false; do { s64 bh_end; bh_end = bh_pos + blocksize; if (bh_end <= pos || bh_pos >= end) { if (!buffer_uptodate(bh)) partial = true; } else { set_buffer_uptodate(bh); mark_buffer_dirty(bh); } } while (bh_pos += blocksize, (bh = bh->b_this_page) != head); /* * If all buffers are now uptodate but the page is not, set the * page uptodate. */ if (!partial && !PageUptodate(page)) SetPageUptodate(page); } while (++u < nr_pages); /* * Finally, if we do not need to update initialized_size or i_size we * are finished. */ read_lock_irqsave(&ni->size_lock, flags); initialized_size = ni->initialized_size; read_unlock_irqrestore(&ni->size_lock, flags); if (end <= initialized_size) { ntfs_debug("Done."); return 0; } /* * Update initialized_size/i_size as appropriate, both in the inode and * the mft record. */ if (!NInoAttr(ni)) base_ni = ni; else base_ni = ni->ext.base_ntfs_ino; /* Map, pin, and lock the mft record. */ m = map_mft_record(base_ni); if (IS_ERR(m)) { err = PTR_ERR(m); m = NULL; ctx = NULL; goto err_out; } BUG_ON(!NInoNonResident(ni)); ctx = ntfs_attr_get_search_ctx(base_ni, m); if (unlikely(!ctx)) { err = -ENOMEM; goto err_out; } err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, 0, NULL, 0, ctx); if (unlikely(err)) { if (err == -ENOENT) err = -EIO; goto err_out; } a = ctx->attr; BUG_ON(!a->non_resident); write_lock_irqsave(&ni->size_lock, flags); BUG_ON(end > ni->allocated_size); ni->initialized_size = end; a->data.non_resident.initialized_size = cpu_to_sle64(end); if (end > i_size_read(vi)) { i_size_write(vi, end); a->data.non_resident.data_size = a->data.non_resident.initialized_size; } write_unlock_irqrestore(&ni->size_lock, flags); /* Mark the mft record dirty, so it gets written back. */ flush_dcache_mft_record_page(ctx->ntfs_ino); mark_mft_record_dirty(ctx->ntfs_ino); ntfs_attr_put_search_ctx(ctx); unmap_mft_record(base_ni); ntfs_debug("Done."); return 0; err_out: if (ctx) ntfs_attr_put_search_ctx(ctx); if (m) unmap_mft_record(base_ni); ntfs_error(vi->i_sb, "Failed to update initialized_size/i_size (error " "code %i).", err); if (err != -ENOMEM) NVolSetErrors(ni->vol); return err; } /** * ntfs_commit_pages_after_write - commit the received data * @pages: array of destination pages * @nr_pages: number of pages in @pages * @pos: byte position in file at which the write begins * @bytes: number of bytes to be written * * This is called from ntfs_file_buffered_write() with i_mutex held on the inode * (@pages[0]->mapping->host). There are @nr_pages pages in @pages which are * locked but not kmap()ped. The source data has already been copied into the * @page. ntfs_prepare_pages_for_non_resident_write() has been called before * the data was copied (for non-resident attributes only) and it returned * success. * * Need to set uptodate and mark dirty all buffers within the boundary of the * write. If all buffers in a page are uptodate we set the page uptodate, too. * * Setting the buffers dirty ensures that they get written out later when * ntfs_writepage() is invoked by the VM. * * Finally, we need to update i_size and initialized_size as appropriate both * in the inode and the mft record. * * This is modelled after fs/buffer.c::generic_commit_write(), which marks * buffers uptodate and dirty, sets the page uptodate if all buffers in the * page are uptodate, and updates i_size if the end of io is beyond i_size. In


context:
space:
mode: