fs: Rename mapping private members

		return ERR_CAST(inode);

	inode->i_mapping->a_ops = &aio_ctx_aops;

	inode->i_mapping->private_data = ctx;

	inode->i_mapping->i_private_data = ctx;

	inode->i_size = PAGE_SIZE * nr_pages;

	file = alloc_file_pseudo(inode, aio_mnt, "[aio]",

		/* Prevent further access to the kioctx from migratepages */

		i_mapping = aio_ring_file->f_mapping;

		spin_lock(&i_mapping->private_lock);

		i_mapping->private_data = NULL;

		spin_lock(&i_mapping->i_private_lock);

		i_mapping->i_private_data = NULL;

		ctx->aio_ring_file = NULL;

		spin_unlock(&i_mapping->private_lock);

		spin_unlock(&i_mapping->i_private_lock);

		fput(aio_ring_file);

	}

	rc = 0;

	/* mapping->private_lock here protects against the kioctx teardown.  */

	spin_lock(&mapping->private_lock);

	ctx = mapping->private_data;

	/* mapping->i_private_lock here protects against the kioctx teardown.  */

	spin_lock(&mapping->i_private_lock);

	ctx = mapping->i_private_data;

	if (!ctx) {

		rc = -EINVAL;

		goto out;

out_unlock:

	mutex_unlock(&ctx->ring_lock);

out:

	spin_unlock(&mapping->private_lock);

	spin_unlock(&mapping->i_private_lock);

	return rc;

}

#else

	 * will not race with any other ebs.

	 */

	if (page->mapping)

		lockdep_assert_held(&page->mapping->private_lock);

		lockdep_assert_held(&page->mapping->i_private_lock);

	if (fs_info->nodesize >= PAGE_SIZE) {

		if (!PagePrivate(page))

		 * Take private lock to ensure the subpage won't be detached

		 * in the meantime.

		 */

		spin_lock(&page->mapping->private_lock);

		spin_lock(&page->mapping->i_private_lock);

		if (!PagePrivate(page)) {

			spin_unlock(&page->mapping->private_lock);

			spin_unlock(&page->mapping->i_private_lock);

			break;

		}

		spin_lock_irqsave(&subpage->lock, flags);

		if (!test_bit(bit_start + fs_info->subpage_info->dirty_offset,

			      subpage->bitmaps)) {

			spin_unlock_irqrestore(&subpage->lock, flags);

			spin_unlock(&page->mapping->private_lock);

			spin_unlock(&page->mapping->i_private_lock);

			bit_start++;

			continue;

		}

		 */

		eb = find_extent_buffer_nolock(fs_info, start);

		spin_unlock_irqrestore(&subpage->lock, flags);

		spin_unlock(&page->mapping->private_lock);

		spin_unlock(&page->mapping->i_private_lock);

		/*

		 * The eb has already reached 0 refs thus find_extent_buffer()

	if (btrfs_sb(page->mapping->host->i_sb)->nodesize < PAGE_SIZE)

		return submit_eb_subpage(page, wbc);

	spin_lock(&mapping->private_lock);

	spin_lock(&mapping->i_private_lock);

	if (!PagePrivate(page)) {

		spin_unlock(&mapping->private_lock);

		spin_unlock(&mapping->i_private_lock);

		return 0;

	}

	 * crashing the machine for something we can survive anyway.

	 */

	if (WARN_ON(!eb)) {

		spin_unlock(&mapping->private_lock);

		spin_unlock(&mapping->i_private_lock);

		return 0;

	}

	if (eb == ctx->eb) {

		spin_unlock(&mapping->private_lock);

		spin_unlock(&mapping->i_private_lock);

		return 0;

	}

	ret = atomic_inc_not_zero(&eb->refs);

	spin_unlock(&mapping->private_lock);

	spin_unlock(&mapping->i_private_lock);

	if (!ret)

		return 0;

{

	struct btrfs_subpage *subpage;

	lockdep_assert_held(&page->mapping->private_lock);

	lockdep_assert_held(&page->mapping->i_private_lock);

	if (PagePrivate(page)) {

		subpage = (struct btrfs_subpage *)page->private;

	/*

	 * For mapped eb, we're going to change the page private, which should

	 * be done under the private_lock.

	 * be done under the i_private_lock.

	 */

	if (mapped)

		spin_lock(&page->mapping->private_lock);

		spin_lock(&page->mapping->i_private_lock);

	if (!PagePrivate(page)) {

		if (mapped)

			spin_unlock(&page->mapping->private_lock);

			spin_unlock(&page->mapping->i_private_lock);

		return;

	}

			detach_page_private(page);

		}

		if (mapped)

			spin_unlock(&page->mapping->private_lock);

			spin_unlock(&page->mapping->i_private_lock);

		return;

	}

	if (!page_range_has_eb(fs_info, page))

		btrfs_detach_subpage(fs_info, page);

	spin_unlock(&page->mapping->private_lock);

	spin_unlock(&page->mapping->i_private_lock);

}

/* Release all pages attached to the extent buffer */

	/*

	 * Preallocate page->private for subpage case, so that we won't

	 * allocate memory with private_lock nor page lock hold.

	 * allocate memory with i_private_lock nor page lock hold.

	 *

	 * The memory will be freed by attach_extent_buffer_page() or freed

	 * manually if we exit earlier.

			goto free_eb;

		}

		spin_lock(&mapping->private_lock);

		spin_lock(&mapping->i_private_lock);

		exists = grab_extent_buffer(fs_info, p);

		if (exists) {

			spin_unlock(&mapping->private_lock);

			spin_unlock(&mapping->i_private_lock);

			unlock_page(p);

			put_page(p);

			mark_extent_buffer_accessed(exists, p);

		 * Thus needs no special handling in error path.

		 */

		btrfs_page_inc_eb_refs(fs_info, p);

		spin_unlock(&mapping->private_lock);

		spin_unlock(&mapping->i_private_lock);

		WARN_ON(btrfs_page_test_dirty(fs_info, p, eb->start, eb->len));

		eb->pages[i] = p;

	 * Finally to check if we have cleared page private, as if we have

	 * released all ebs in the page, the page private should be cleared now.

	 */

	spin_lock(&page->mapping->private_lock);

	spin_lock(&page->mapping->i_private_lock);

	if (!PagePrivate(page))

		ret = 1;

	else

		ret = 0;

	spin_unlock(&page->mapping->private_lock);

	spin_unlock(&page->mapping->i_private_lock);

	return ret;

}

	 * We need to make sure nobody is changing page->private, as we rely on

	 * page->private as the pointer to extent buffer.

	 */

	spin_lock(&page->mapping->private_lock);

	spin_lock(&page->mapping->i_private_lock);

	if (!PagePrivate(page)) {

		spin_unlock(&page->mapping->private_lock);

		spin_unlock(&page->mapping->i_private_lock);

		return 1;

	}

	spin_lock(&eb->refs_lock);

	if (atomic_read(&eb->refs) != 1 || extent_buffer_under_io(eb)) {

		spin_unlock(&eb->refs_lock);

		spin_unlock(&page->mapping->private_lock);

		spin_unlock(&page->mapping->i_private_lock);

		return 0;

	}

	spin_unlock(&page->mapping->private_lock);

	spin_unlock(&page->mapping->i_private_lock);

	/*

	 * If tree ref isn't set then we know the ref on this eb is a real ref,

		return;

	ASSERT(PagePrivate(page) && page->mapping);

	lockdep_assert_held(&page->mapping->private_lock);

	lockdep_assert_held(&page->mapping->i_private_lock);

	subpage = (struct btrfs_subpage *)page->private;

	atomic_inc(&subpage->eb_refs);

		return;

	ASSERT(PagePrivate(page) && page->mapping);

	lockdep_assert_held(&page->mapping->private_lock);

	lockdep_assert_held(&page->mapping->i_private_lock);

	subpage = (struct btrfs_subpage *)page->private;

	ASSERT(atomic_read(&subpage->eb_refs));

 * Various filesystems appear to want __find_get_block to be non-blocking.

 * But it's the page lock which protects the buffers.  To get around this,

 * we get exclusion from try_to_free_buffers with the blockdev mapping's

 * private_lock.

 * i_private_lock.

 *

 * Hack idea: for the blockdev mapping, private_lock contention

 * Hack idea: for the blockdev mapping, i_private_lock contention

 * may be quite high.  This code could TryLock the page, and if that

 * succeeds, there is no need to take private_lock.

 * succeeds, there is no need to take i_private_lock.

 */

static struct buffer_head *

__find_get_block_slow(struct block_device *bdev, sector_t block)

	if (IS_ERR(folio))

		goto out;

	spin_lock(&bd_mapping->private_lock);

	spin_lock(&bd_mapping->i_private_lock);

	head = folio_buffers(folio);

	if (!head)

		goto out_unlock;

		       1 << bd_inode->i_blkbits);

	}

out_unlock:

	spin_unlock(&bd_mapping->private_lock);

	spin_unlock(&bd_mapping->i_private_lock);

	folio_put(folio);

out:

	return ret;

 *

 * The functions mark_buffer_inode_dirty(), fsync_inode_buffers(),

 * inode_has_buffers() and invalidate_inode_buffers() are provided for the

 * management of a list of dependent buffers at ->i_mapping->private_list.

 * management of a list of dependent buffers at ->i_mapping->i_private_list.

 *

 * Locking is a little subtle: try_to_free_buffers() will remove buffers

 * from their controlling inode's queue when they are being freed.  But

 * try_to_free_buffers() will be operating against the *blockdev* mapping

 * at the time, not against the S_ISREG file which depends on those buffers.

 * So the locking for private_list is via the private_lock in the address_space

 * So the locking for i_private_list is via the i_private_lock in the address_space

 * which backs the buffers.  Which is different from the address_space 

 * against which the buffers are listed.  So for a particular address_space,

 * mapping->private_lock does *not* protect mapping->private_list!  In fact,

 * mapping->private_list will always be protected by the backing blockdev's

 * ->private_lock.

 * mapping->i_private_lock does *not* protect mapping->i_private_list!  In fact,

 * mapping->i_private_list will always be protected by the backing blockdev's

 * ->i_private_lock.

 *

 * Which introduces a requirement: all buffers on an address_space's

 * ->private_list must be from the same address_space: the blockdev's.

 * ->i_private_list must be from the same address_space: the blockdev's.

 *

 * address_spaces which do not place buffers at ->private_list via these

 * utility functions are free to use private_lock and private_list for

 * whatever they want.  The only requirement is that list_empty(private_list)

 * address_spaces which do not place buffers at ->i_private_list via these

 * utility functions are free to use i_private_lock and i_private_list for

 * whatever they want.  The only requirement is that list_empty(i_private_list)

 * be true at clear_inode() time.

 *

 * FIXME: clear_inode should not call invalidate_inode_buffers().  The

 */

/*

 * The buffer's backing address_space's private_lock must be held

 * The buffer's backing address_space's i_private_lock must be held

 */

static void __remove_assoc_queue(struct buffer_head *bh)

{

int inode_has_buffers(struct inode *inode)

{

	return !list_empty(&inode->i_data.private_list);

	return !list_empty(&inode->i_data.i_private_list);

}

/*

 * sync_mapping_buffers - write out & wait upon a mapping's "associated" buffers

 * @mapping: the mapping which wants those buffers written

 *

 * Starts I/O against the buffers at mapping->private_list, and waits upon

 * Starts I/O against the buffers at mapping->i_private_list, and waits upon

 * that I/O.

 *

 * Basically, this is a convenience function for fsync().

 */

int sync_mapping_buffers(struct address_space *mapping)

{

	struct address_space *buffer_mapping = mapping->private_data;

	struct address_space *buffer_mapping = mapping->i_private_data;

	if (buffer_mapping == NULL || list_empty(&mapping->private_list))

	if (buffer_mapping == NULL || list_empty(&mapping->i_private_list))

		return 0;

	return fsync_buffers_list(&buffer_mapping->private_lock,

					&mapping->private_list);

	return fsync_buffers_list(&buffer_mapping->i_private_lock,

					&mapping->i_private_list);

}

EXPORT_SYMBOL(sync_mapping_buffers);

	struct address_space *buffer_mapping = bh->b_folio->mapping;

	mark_buffer_dirty(bh);

	if (!mapping->private_data) {

		mapping->private_data = buffer_mapping;

	if (!mapping->i_private_data) {

		mapping->i_private_data = buffer_mapping;

	} else {

		BUG_ON(mapping->private_data != buffer_mapping);

		BUG_ON(mapping->i_private_data != buffer_mapping);

	}

	if (!bh->b_assoc_map) {

		spin_lock(&buffer_mapping->private_lock);

		spin_lock(&buffer_mapping->i_private_lock);

		list_move_tail(&bh->b_assoc_buffers,

				&mapping->private_list);

				&mapping->i_private_list);

		bh->b_assoc_map = mapping;

		spin_unlock(&buffer_mapping->private_lock);

		spin_unlock(&buffer_mapping->i_private_lock);

	}

}

EXPORT_SYMBOL(mark_buffer_dirty_inode);

 * bit, see a bunch of clean buffers and we'd end up with dirty buffers/clean

 * page on the dirty page list.

 *

 * We use private_lock to lock against try_to_free_buffers while using the

 * We use i_private_lock to lock against try_to_free_buffers while using the

 * page's buffer list.  Also use this to protect against clean buffers being

 * added to the page after it was set dirty.

 *

	struct buffer_head *head;

	bool newly_dirty;

	spin_lock(&mapping->private_lock);

	spin_lock(&mapping->i_private_lock);

	head = folio_buffers(folio);

	if (head) {

		struct buffer_head *bh = head;

	 */

	folio_memcg_lock(folio);

	newly_dirty = !folio_test_set_dirty(folio);

	spin_unlock(&mapping->private_lock);

	spin_unlock(&mapping->i_private_lock);

	if (newly_dirty)

		__folio_mark_dirty(folio, mapping, 1);

		smp_mb();

		if (buffer_dirty(bh)) {

			list_add(&bh->b_assoc_buffers,

				 &mapping->private_list);

				 &mapping->i_private_list);

			bh->b_assoc_map = mapping;

		}

		spin_unlock(lock);

 * probably unmounting the fs, but that doesn't mean we have already

 * done a sync().  Just drop the buffers from the inode list.

 *

 * NOTE: we take the inode's blockdev's mapping's private_lock.  Which

 * NOTE: we take the inode's blockdev's mapping's i_private_lock.  Which

 * assumes that all the buffers are against the blockdev.  Not true

 * for reiserfs.

 */

{

	if (inode_has_buffers(inode)) {

		struct address_space *mapping = &inode->i_data;

		struct list_head *list = &mapping->private_list;

		struct address_space *buffer_mapping = mapping->private_data;

		struct list_head *list = &mapping->i_private_list;

		struct address_space *buffer_mapping = mapping->i_private_data;

		spin_lock(&buffer_mapping->private_lock);

		spin_lock(&buffer_mapping->i_private_lock);

		while (!list_empty(list))

			__remove_assoc_queue(BH_ENTRY(list->next));

		spin_unlock(&buffer_mapping->private_lock);

		spin_unlock(&buffer_mapping->i_private_lock);

	}

}

EXPORT_SYMBOL(invalidate_inode_buffers);

	if (inode_has_buffers(inode)) {

		struct address_space *mapping = &inode->i_data;

		struct list_head *list = &mapping->private_list;

		struct address_space *buffer_mapping = mapping->private_data;

		struct list_head *list = &mapping->i_private_list;

		struct address_space *buffer_mapping = mapping->i_private_data;

		spin_lock(&buffer_mapping->private_lock);

		spin_lock(&buffer_mapping->i_private_lock);

		while (!list_empty(list)) {

			struct buffer_head *bh = BH_ENTRY(list->next);

			if (buffer_dirty(bh)) {

			}

			__remove_assoc_queue(bh);

		}

		spin_unlock(&buffer_mapping->private_lock);

		spin_unlock(&buffer_mapping->i_private_lock);

	}

	return ret;

}

	 * lock to be atomic wrt __find_get_block(), which does not

	 * run under the folio lock.

	 */

	spin_lock(&inode->i_mapping->private_lock);

	spin_lock(&inode->i_mapping->i_private_lock);

	link_dev_buffers(folio, bh);

	end_block = folio_init_buffers(folio, bdev,

			(sector_t)index << sizebits, size);

	spin_unlock(&inode->i_mapping->private_lock);

	spin_unlock(&inode->i_mapping->i_private_lock);

done:

	ret = (block < end_block) ? 1 : -ENXIO;

failed:

 * and then attach the address_space's inode to its superblock's dirty

 * inode list.

 *

 * mark_buffer_dirty() is atomic.  It takes bh->b_folio->mapping->private_lock,

 * mark_buffer_dirty() is atomic.  It takes bh->b_folio->mapping->i_private_lock,

 * i_pages lock and mapping->host->i_lock.

 */

void mark_buffer_dirty(struct buffer_head *bh)

	if (bh->b_assoc_map) {

		struct address_space *buffer_mapping = bh->b_folio->mapping;

		spin_lock(&buffer_mapping->private_lock);

		spin_lock(&buffer_mapping->i_private_lock);

		list_del_init(&bh->b_assoc_buffers);

		bh->b_assoc_map = NULL;

		spin_unlock(&buffer_mapping->private_lock);

		spin_unlock(&buffer_mapping->i_private_lock);

	}

	__brelse(bh);

}

/*

 * We attach and possibly dirty the buffers atomically wrt

 * block_dirty_folio() via private_lock.  try_to_free_buffers

 * block_dirty_folio() via i_private_lock.  try_to_free_buffers

 * is already excluded via the folio lock.

 */

struct buffer_head *create_empty_buffers(struct folio *folio,

	} while (bh);

	tail->b_this_page = head;

	spin_lock(&folio->mapping->private_lock);

	spin_lock(&folio->mapping->i_private_lock);

	if (folio_test_uptodate(folio) || folio_test_dirty(folio)) {

		bh = head;

		do {

		} while (bh != head);

	}

	folio_attach_private(folio, head);

	spin_unlock(&folio->mapping->private_lock);

	spin_unlock(&folio->mapping->i_private_lock);

	return head;

}

			if (!folio_buffers(folio))

				continue;

			/*

			 * We use folio lock instead of bd_mapping->private_lock

			 * We use folio lock instead of bd_mapping->i_private_lock

			 * to pin buffers here since we can afford to sleep and

			 * it scales better than a global spinlock lock.

			 */

 * are unused, and releases them if so.

 *

 * Exclusion against try_to_free_buffers may be obtained by either

 * locking the folio or by holding its mapping's private_lock.

 * locking the folio or by holding its mapping's i_private_lock.

 *

 * If the folio is dirty but all the buffers are clean then we need to

 * be sure to mark the folio clean as well.  This is because the folio

 * The same applies to regular filesystem folios: if all the buffers are

 * clean then we set the folio clean and proceed.  To do that, we require

 * total exclusion from block_dirty_folio().  That is obtained with

 * private_lock.

 * i_private_lock.

 *

 * try_to_free_buffers() is non-blocking.

 */

		goto out;

	}

	spin_lock(&mapping->private_lock);

	spin_lock(&mapping->i_private_lock);

	ret = drop_buffers(folio, &buffers_to_free);

	/*

	 * the folio's buffers clean.  We discover that here and clean

	 * the folio also.

	 *

	 * private_lock must be held over this entire operation in order

	 * i_private_lock must be held over this entire operation in order

	 * to synchronise against block_dirty_folio and prevent the

	 * dirty bit from being lost.

	 */

	if (ret)

		folio_cancel_dirty(folio);

	spin_unlock(&mapping->private_lock);

	spin_unlock(&mapping->i_private_lock);

out:

	if (buffers_to_free) {

		struct buffer_head *bh = buffers_to_free;

 * We need to pick up the new inode size which generic_commit_write gave us

 * `file' can be NULL - eg, when called from page_symlink().

 *

 * ext4 never places buffers on inode->i_mapping->private_list.  metadata

 * ext4 never places buffers on inode->i_mapping->i_private_list.  metadata

 * buffers are managed internally.

 */

static int ext4_write_end(struct file *file,

	}

	/* Any metadata buffers to write? */

	if (!list_empty(&inode->i_mapping->private_list))

	if (!list_empty(&inode->i_mapping->i_private_list))

		return true;

	return inode->i_state & I_DIRTY_DATASYNC;

}