docs/vfs: update references to i_mutex to i_rwsem

dirty_folio to write data into the address_space, and

writepages to writeback data to storage.

Adding and removing pages to/from an address_space is protected by the

inode's i_mutex.

Removing pages from an address_space requires holding the inode's i_rwsem

exclusively, while adding pages to the address_space requires holding the

inode's i_mapping->invalidate_lock exclusively.

When data is written to a page, the PG_Dirty flag should be set.  It

typically remains set until writepages asks for it to be written.  This

 * @inode:	the inode to be truncated

 * @offset:	the new size to assign to the inode

 *

 * inode_newsize_ok must be called with i_mutex held.

 * inode_newsize_ok must be called with i_rwsem held exclusively.

 *

 * inode_newsize_ok will check filesystem limits and ulimits to check that the

 * new inode size is within limits. inode_newsize_ok will also send SIGXFSZ

 * @inode:	the inode to be updated

 * @attr:	the new attributes

 *

 * setattr_copy must be called with i_mutex held.

 * setattr_copy must be called with i_rwsem held exclusively.

 *

 * setattr_copy updates the inode's metadata with that specified

 * in attr on idmapped mounts. Necessary permission checks to determine

 * @attr:	new attributes

 * @delegated_inode: returns inode, if the inode is delegated

 *

 * The caller must hold the i_mutex on the affected object.

 * The caller must hold the i_rwsem exclusively on the affected object.

 *

 * If notify_change discovers a delegation in need of breaking,

 * it will return -EWOULDBLOCK and return a reference to the inode in

 * delegated_inode.  The caller should then break the delegation and

 * retry.  Because breaking a delegation may take a long time, the

 * caller should drop the i_mutex before doing so.

 * caller should drop the i_rwsem before doing so.

 *

 * Alternatively, a caller may pass NULL for delegated_inode.  This may

 * be appropriate for callers that expect the underlying filesystem not

		if (S_ISLNK(inode->i_mode))

			return -EOPNOTSUPP;

		/* Flag setting protected by i_mutex */

		/* Flag setting protected by i_rwsem */

		if (is_sxid(attr->ia_mode))

			inode->i_flags &= ~S_NOSEC;

	}

 * holes and correct delalloc and unwritten extent mapping on filesystems that

 * support these features.

 *

 * We are not allowed to take the i_mutex here so we have to play games to

 * We are not allowed to take the i_rwsem here so we have to play games to

 * protect against truncate races as the page could now be beyond EOF.  Because

 * truncate writes the inode size before removing pages, once we have the

 * page lock we can determine safely if the page is beyond EOF. If it is not

 * @target: new dentry

 * @exchange: exchange the two dentries

 *

 * Update the dcache to reflect the move of a file name. Negative

 * dcache entries should not be moved in this way. Caller must hold

 * rename_lock, the i_mutex of the source and target directories,

 * and the sb->s_vfs_rename_mutex if they differ. See lock_rename().

 * Update the dcache to reflect the move of a file name. Negative dcache

 * entries should not be moved in this way. Caller must hold rename_lock, the

 * i_rwsem of the source and target directories (exclusively), and the sb->

 * s_vfs_rename_mutex if they differ. See lock_rename().

 */

static void __d_move(struct dentry *dentry, struct dentry *target,

		     bool exchange)

 * This helper attempts to cope with remotely renamed directories

 *

 * It assumes that the caller is already holding

 * dentry->d_parent->d_inode->i_mutex, and rename_lock

 * dentry->d_parent->d_inode->i_rwsem, and rename_lock

 *

 * Note: If ever the locking in lock_rename() changes, then please

 * remember to update this too...

 * The locking rules are governed by the flags parameter:

 *  - if the flags value contains DIO_LOCKING we use a fancy locking

 *    scheme for dumb filesystems.

 *    For writes this function is called under i_mutex and returns with

 *    i_mutex held, for reads, i_mutex is not held on entry, but it is

 *    For writes this function is called under i_rwsem and returns with

 *    i_rwsem held, for reads, i_rwsem is not held on entry, but it is

 *    taken and dropped again before returning.

 *  - if the flags value does NOT contain DIO_LOCKING we don't use any

 *    internal locking but rather rely on the filesystem to synchronize

 * counter before starting direct I/O, and decrement it once we are done.

 * Truncate can wait for it to reach zero to provide exclusion.  It is

 * expected that filesystem provide exclusion between new direct I/O

 * and truncates.  For DIO_LOCKING filesystems this is done by i_mutex,

 * and truncates.  For DIO_LOCKING filesystems this is done by i_rwsem,

 * but other filesystems need to take care of this on their own.

 *

 * NOTE: if you pass "sdio" to anything by pointer make sure that function

	/*

	 * All block lookups have been performed. For READ requests

	 * we can let i_mutex go now that its achieved its purpose

	 * we can let i_rwsem go now that its achieved its purpose

	 * of protecting us from looking up uninitialized blocks.

	 */

	if (iov_iter_rw(iter) == READ && (dio->flags & DIO_LOCKING))