Merge 5.16-rc4 into tty-next

virtual address size configured by the kernel. For example, with a

virtual address size of 48, the PAC is 7 bits wide.

Recent versions of GCC can compile code with APIAKey-based return

address protection when passed the -msign-return-address option. This

uses instructions in the HINT space (unless -march=armv8.3-a or higher

is also passed), and such code can run on systems without the pointer

authentication extension.

When ARM64_PTR_AUTH_KERNEL is selected, the kernel will be compiled

with HINT space pointer authentication instructions protecting

function returns. Kernels built with this option will work on hardware

with or without pointer authentication support.

In addition to exec(), keys can also be reinitialized to random values

using the PR_PAC_RESET_KEYS prctl. A bitmask of PR_PAC_APIAKEY,

The third argument is a struct cpufreq_freqs with the following

values:

=====	===========================

cpu	number of the affected CPU

======	======================================

policy	a pointer to the struct cpufreq_policy

old	old frequency

new	new frequency

flags	flags of the cpufreq driver

=====	===========================

======	======================================

3. CPUFreq Table Generation with Operating Performance Point (OPP)

==================================================================

    oneOf:

      - enum:

          - fsl,imx7ulp-lpi2c

          - fsl,imx8qm-lpi2c

      - items:

          - const: fsl,imx8qxp-lpi2c

          - enum:

              - fsl,imx8qxp-lpi2c

              - fsl,imx8qm-lpi2c

          - const: fsl,imx7ulp-lpi2c

  reg:

2. Enable one of components (smb, auth, vfs, oplock, ipc, conn, rdma)

	# sudo ksmbd.control -d "smb"

3. Show what prints are enable.

3. Show what prints are enabled.

	# cat /sys/class/ksmbd-control/debug

	  [smb] auth vfs oplock ipc conn [rdma]

.. SPDX-License-Identifier: GPL-2.0

=================================

NETWORK FILESYSTEM HELPER LIBRARY

Network Filesystem Helper Library

=================================

.. Contents:

The following services are provided:

 * Handles transparent huge pages (THPs).

 * Handle folios that span multiple pages.

 * Insulates the netfs from VM interface changes.

 * Insulate the netfs from VM interface changes.

 * Allows the netfs to arbitrarily split reads up into pieces, even ones that

   don't match page sizes or page alignments and that may cross pages.

 * Allow the netfs to arbitrarily split reads up into pieces, even ones that

   don't match folio sizes or folio alignments and that may cross folios.

 * Allows the netfs to expand a readahead request in both directions to meet

   its needs.

 * Allow the netfs to expand a readahead request in both directions to meet its

   needs.

 * Allows the netfs to partially fulfil a read, which will then be resubmitted.

 * Allow the netfs to partially fulfil a read, which will then be resubmitted.

 * Handles local caching, allowing cached data and server-read data to be

 * Handle local caching, allowing cached data and server-read data to be

   interleaved for a single request.

 * Handles clearing of bufferage that aren't on the server.

 * Handle clearing of bufferage that aren't on the server.

 * Handle retrying of reads that failed, switching reads from the cache to the

   server as necessary.

Three read helpers are provided::

 * void netfs_readahead(struct readahead_control *ractl,

	void netfs_readahead(struct readahead_control *ractl,

			     const struct netfs_read_request_ops *ops,

			void *netfs_priv);``

 * int netfs_readpage(struct file *file,

		      struct page *page,

			     void *netfs_priv);

	int netfs_readpage(struct file *file,

			   struct folio *folio,

			   const struct netfs_read_request_ops *ops,

			   void *netfs_priv);

 * int netfs_write_begin(struct file *file,

	int netfs_write_begin(struct file *file,

			      struct address_space *mapping,

			      loff_t pos,

			      unsigned int len,

			      unsigned int flags,

			 struct page **_page,

			      struct folio **_folio,

			      void **_fsdata,

			      const struct netfs_read_request_ops *ops,

			      void *netfs_priv);

For ->readahead() and ->readpage(), the network filesystem should just jump

into the corresponding read helper; whereas for ->write_begin(), it may be a

little more complicated as the network filesystem might want to flush

conflicting writes or track dirty data and needs to put the acquired page if an

error occurs after calling the helper.

conflicting writes or track dirty data and needs to put the acquired folio if

an error occurs after calling the helper.

The helpers manage the read request, calling back into the network filesystem

through the suppplied table of operations.  Waits will be performed as

		void (*issue_op)(struct netfs_read_subrequest *subreq);

		bool (*is_still_valid)(struct netfs_read_request *rreq);

		int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,

					 struct page *page, void **_fsdata);

					 struct folio *folio, void **_fsdata);

		void (*done)(struct netfs_read_request *rreq);

		void (*cleanup)(struct address_space *mapping, void *netfs_priv);

	};

   There is no return value; the netfs_subreq_terminated() function should be

   called to indicate whether or not the operation succeeded and how much data

   it transferred.  The filesystem also should not deal with setting pages

   it transferred.  The filesystem also should not deal with setting folios

   uptodate, unlocking them or dropping their refs - the helpers need to deal

   with this as they have to coordinate with copying to the local cache.

   Note that the helpers have the pages locked, but not pinned.  It is possible

   to use the ITER_XARRAY iov iterator to refer to the range of the inode that

   is being operated upon without the need to allocate large bvec tables.

   Note that the helpers have the folios locked, but not pinned.  It is

   possible to use the ITER_XARRAY iov iterator to refer to the range of the

   inode that is being operated upon without the need to allocate large bvec

   tables.

 * ``is_still_valid()``

 * ``check_write_begin()``

   [Optional] This is called from the netfs_write_begin() helper once it has

   allocated/grabbed the page to be modified to allow the filesystem to flush

   allocated/grabbed the folio to be modified to allow the filesystem to flush

   conflicting state before allowing it to be modified.

   It should return 0 if everything is now fine, -EAGAIN if the page should be

   It should return 0 if everything is now fine, -EAGAIN if the folio should be

   regrabbed and any other error code to abort the operation.

 * ``done``

   [Optional] This is called after the pages in the request have all been

   [Optional] This is called after the folios in the request have all been

   unlocked (and marked uptodate if applicable).

 * ``cleanup``

     * If NETFS_SREQ_CLEAR_TAIL was set, a short read will be cleared to the

       end of the slice instead of reissuing.

 * Once the data is read, the pages that have been fully read/cleared:

 * Once the data is read, the folios that have been fully read/cleared:

   * Will be marked uptodate.

   * Unlocked

 * Any pages that need writing to the cache will then have DIO writes issued.

 * Any folios that need writing to the cache will then have DIO writes issued.

 * Synchronous operations will wait for reading to be complete.

 * Writes to the cache will proceed asynchronously and the pages will have the

 * Writes to the cache will proceed asynchronously and the folios will have the

   PG_fscache mark removed when that completes.

 * The request structures will be cleaned up when everything has completed.

			    netfs_io_terminated_t term_func,

			    void *term_func_priv);

		int (*prepare_write)(struct netfs_cache_resources *cres,

				     loff_t *_start, size_t *_len, loff_t i_size);

		int (*write)(struct netfs_cache_resources *cres,

			     loff_t start_pos,

			     struct iov_iter *iter,

   indicating whether the termination is definitely happening in the caller's

   context.

 * ``prepare_write()``

   [Required] Called to adjust a write to the cache and check that there is

   sufficient space in the cache.  The start and length values indicate the

   size of the write that netfslib is proposing, and this can be adjusted by

   the cache to respect DIO boundaries.  The file size is passed for

   information.

 * ``write()``

   [Required] Called to write to the cache.  The start file offset is given

there isn't a read request structure as well, such as writing dirty data to the

cache.

API Function Reference

======================

.. kernel-doc:: include/linux/netfs.h

.. kernel-doc:: fs/netfs/read_helper.c