* [PATCH v4 0/2] kheaders fixes for -rc
From: Joel Fernandes (Google) @ 2019-05-15 21:35 UTC (permalink / raw)
To: linux-kernel
Cc: Joel Fernandes (Google), Adrian Ratiu, Alexei Starovoitov,
Andrew Morton, atishp04, bpf, Brendan Gregg, Brendan Gregg,
dancol, Daniel Borkmann, Dan Williams, dietmar.eggemann, duyuchao,
gregkh, Guenter Roeck, Jonathan Corbet, Karim Yaghmour, Kees Cook,
kernel-team, linux-doc, linux-kselftest, linux-trace-devel,
Manjo Raja Rao, Masahiro Yamada, Masami Hiramatsu,
Michał Gregorczyk, Michal Gregorczyk, Mohammad Husain,
Olof Johansson, qais.yousef, rdunlap, rostedt, Shuah Khan,
Srinivas Ramana, Tamir Carmeli, yhs
Linus, Greg, Masahiro, Here are some simple fixes for the kheaders feature.
Please consider these patches for an rc release. They are based on Linus's
master branch. The only difference between the last series [1] and this one is
I squashed 1/3 and 3/3 and rebased. Thanks!
[1] https://patchwork.kernel.org/cover/10939557/
Joel Fernandes (Google) (2):
kheaders: Move from proc to sysfs
kheaders: Do not regenerate archive if config is not changed
init/Kconfig | 17 +++++----
kernel/Makefile | 4 +--
kernel/{gen_ikh_data.sh => gen_kheaders.sh} | 17 ++++++---
kernel/kheaders.c | 40 +++++++++------------
4 files changed, 38 insertions(+), 40 deletions(-)
rename kernel/{gen_ikh_data.sh => gen_kheaders.sh} (82%)
--
2.21.0.1020.gf2820cf01a-goog
^ permalink raw reply
* [TRIVIA] Re: [PATCH] docs: Move kref.txt to core-api/kref.rst
From: Jonathan Corbet @ 2019-05-15 16:56 UTC (permalink / raw)
To: Tobin C. Harding
Cc: Thomas Hellstrom, linux-kernel@vger.kernel.org, minyard@acm.org,
linux-doc@vger.kernel.org, Tobin C. Harding
In-Reply-To: <f48e76f7-6b95-4cf0-82af-424119bb2eb4@www.fastmail.com>
On Fri, 10 May 2019 16:45:45 -0400
"Tobin C. Harding" <me@tobin.cc> wrote:
> I read once that they used 72 characters on punch cards at times because
> the other 8 characters got mangled for some reason.
Those of use who worked in Fortran understand these things... columns
73-80 were ignored by the compiler. The normal use was to put line
numbers in there to help recovery when you dropped your card deck on the
floor and had to unshuffle things. A diagonal line drawn across the
top of deck helped a lot, but it was good to have verification for the
marginal cases.
Kids today just don't have any culture at all...:)
jon
^ permalink raw reply
* Re: [PATCH v3 15/18] Documentation: kunit: add documentation for KUnit
From: Jonathan Corbet @ 2019-05-15 13:45 UTC (permalink / raw)
To: Brendan Higgins
Cc: frowand.list, gregkh, keescook, kieran.bingham, mcgrof, robh,
sboyd, shuah, tytso, yamada.masahiro, devicetree, dri-devel,
kunit-dev, linux-doc, linux-fsdevel, linux-kbuild, linux-kernel,
linux-kselftest, linux-nvdimm, linux-um, Alexander.Levin,
Tim.Bird, amir73il, dan.carpenter, dan.j.williams, daniel, jdike,
joel, julia.lawall, khilman, knut.omang, logang, mpe, pmladek,
rdunlap, richard, rientjes, rostedt, wfg, Felix Guo
In-Reply-To: <20190514231902.GA12893@google.com>
On Tue, 14 May 2019 16:19:02 -0700
Brendan Higgins <brendanhiggins@google.com> wrote:
> Hmmm...probably premature to bring this up, but Documentation/dev-tools/
> is kind of thrown together.
Wait a minute, man... *I* created that directory, are you impugning my
work? :)
But yes, "kind of thrown together" is a good description of much of
Documentation/. A number of people have been working for years to make
that better, with some success, but there is a long way to go yet. The
dev-tools directory is an improvement over having that stuff scattered all
over the place — at least it's actually thrown together — but it's not the
end point.
> It would be nice to provide a coherent overview, maybe provide some
> basic grouping as well.
>
> It would be nice if there was kind of a gentle introduction to the
> tools, which ones you should be looking at, when, why, etc.
Total agreement. All we need is somebody to write it! :)
Thanks,
jon
^ permalink raw reply
* hello
From: eddy william @ 2019-05-15 11:55 UTC (permalink / raw)
Mijn naam is Eddy William. Ik ben van beroep advocaat. Ik wil je aanbieden
nabestaanden van mijn cliënt. Je ervaart de som van ($ 14,2 miljoen)
dollars die mijn cliënt voor zijn overlijden op de bank heeft achtergelaten.
Mijn klant is een burger van jouw land die stierf in auto-ongeluk met zijn vrouw
en alleen zoon. Ik krijg 50% van het totale fonds en 50% wel
voor jou zijn.
Neem hier voor meer informatie contact op met mijn privémail:
eddywilliam0002@gmail.com
Bij voorbaat hartelijk dank,
Eddy William,
Hello
My name is Eddy William I am a lawyer by profession. I wish to offer you
the next of kin to my client. You will inherit the sum of ($14.2 Million)
dollars my client left in the bank before his death.
My client is a citizen of your country who died in auto crash with his wife
and only son. I will be entitled with 50% of the total fund while 50% will
be for you.
Please contact my private email here for more details:eddywilliam0002@gmail.com
Many thanks in advance,
Mr.Eddy William,
^ permalink raw reply
* Re: [PATCH v3 2/2] ftpm: add documentation for ftpm driver
From: Jarkko Sakkinen @ 2019-05-15 8:14 UTC (permalink / raw)
To: Sasha Levin
Cc: peterhuewe, jgg, corbet, linux-kernel, linux-doc, linux-integrity,
linux-kernel, thiruan, bryankel
In-Reply-To: <20190415155636.32748-3-sashal@kernel.org>
On Mon, Apr 15, 2019 at 11:56:36AM -0400, Sasha Levin wrote:
> This patch adds basic documentation to describe the new fTPM driver.
>
> Signed-off-by: Sasha Levin <sashal@kernel.org>
> Signed-off-by: Sasha Levin (Microsoft) <sashal@kernel.org>
> ---
> Documentation/security/tpm/index.rst | 1 +
> Documentation/security/tpm/tpm_ftpm_tee.rst | 31 +++++++++++++++++++++
> 2 files changed, 32 insertions(+)
> create mode 100644 Documentation/security/tpm/tpm_ftpm_tee.rst
>
> diff --git a/Documentation/security/tpm/index.rst b/Documentation/security/tpm/index.rst
> index af77a7bbb070..15783668644f 100644
> --- a/Documentation/security/tpm/index.rst
> +++ b/Documentation/security/tpm/index.rst
> @@ -4,4 +4,5 @@ Trusted Platform Module documentation
>
> .. toctree::
>
> + tpm_ftpm_tee
> tpm_vtpm_proxy
> diff --git a/Documentation/security/tpm/tpm_ftpm_tee.rst b/Documentation/security/tpm/tpm_ftpm_tee.rst
> new file mode 100644
> index 000000000000..29c2f8b5ed10
> --- /dev/null
> +++ b/Documentation/security/tpm/tpm_ftpm_tee.rst
> @@ -0,0 +1,31 @@
> +=============================================
> +Firmware TPM Driver
> +=============================================
> +
> +| Authors:
> +| Thirupathaiah Annapureddy <thiruan@microsoft.com>
> +| Sasha Levin <sashal@kernel.org>
> +
> +This document describes the firmware Trusted Platform Module (fTPM)
> +device driver.
> +
> +Introduction
> +============
> +
> +This driver is a shim for a firmware implemented in ARM's TrustZone
> +environment. The driver allows programs to interact with the TPM in the same
> +way the would interact with a hardware TPM.
> +
> +Design
> +======
> +
> +The driver acts as a thin layer that passes commands to and from a TPM
> +implemented in firmware. The driver itself doesn't contain much logic and is
> +used more like a dumb pipe between firmware and kernel/userspace.
> +
> +The firmware itself is based on the following paper:
> +https://www.microsoft.com/en-us/research/wp-content/uploads/2017/06/ftpm1.pdf
> +
> +When the driver is loaded it will expose ``/dev/tpmX`` character devices to
> +userspace which will enable userspace to communicate with the firmware tpm
> +through this device.
> --
> 2.19.1
>
Actually this would a better place at least with some words to describe
what is TEE. I'm, for example, confused whether there is only single TEE
in existence always used with TZ or is this some MS specific TEE.
Otherwise, looks legit.
/Jarkko
^ permalink raw reply
* Re: [PATCH v3 1/2] ftpm: firmware TPM running in TEE
From: Jarkko Sakkinen @ 2019-05-15 8:12 UTC (permalink / raw)
To: Sasha Levin
Cc: peterhuewe, jgg, corbet, linux-kernel, linux-doc, linux-integrity,
linux-kernel, thiruan, bryankel
In-Reply-To: <20190415155636.32748-2-sashal@kernel.org>
On Mon, Apr 15, 2019 at 11:56:35AM -0400, Sasha Levin wrote:
> This patch adds support for a software-only implementation of a TPM
> running in TEE.
>
> There is extensive documentation of the design here:
> https://www.microsoft.com/en-us/research/publication/ftpm-software-implementation-tpm-chip/ .
>
> As well as reference code for the firmware available here:
> https://github.com/Microsoft/ms-tpm-20-ref/tree/master/Samples/ARM32-FirmwareTPM
The commit message should include at least a brief description what TEE
is.
>
> Signed-off-by: Thirupathaiah Annapureddy <thiruan@microsoft.com>
> Signed-off-by: Sasha Levin <sashal@kernel.org>
> ---
> drivers/char/tpm/Kconfig | 5 +
> drivers/char/tpm/Makefile | 1 +
> drivers/char/tpm/tpm_ftpm_tee.c | 366 ++++++++++++++++++++++++++++++++
> drivers/char/tpm/tpm_ftpm_tee.h | 47 ++++
> 4 files changed, 419 insertions(+)
> create mode 100644 drivers/char/tpm/tpm_ftpm_tee.c
> create mode 100644 drivers/char/tpm/tpm_ftpm_tee.h
>
> diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig
> index 536e55d3919f..5638726641eb 100644
> --- a/drivers/char/tpm/Kconfig
> +++ b/drivers/char/tpm/Kconfig
> @@ -164,6 +164,11 @@ config TCG_VTPM_PROXY
> /dev/vtpmX and a server-side file descriptor on which the vTPM
> can receive commands.
>
> +config TCG_FTPM_TEE
> + tristate "TEE based fTPM Interface"
> + depends on TEE
> + ---help---
> + This driver proxies for fTPM running in TEE
>
> source "drivers/char/tpm/st33zp24/Kconfig"
> endif # TCG_TPM
> diff --git a/drivers/char/tpm/Makefile b/drivers/char/tpm/Makefile
> index a01c4cab902a..c354cdff9c62 100644
> --- a/drivers/char/tpm/Makefile
> +++ b/drivers/char/tpm/Makefile
> @@ -33,3 +33,4 @@ obj-$(CONFIG_TCG_TIS_ST33ZP24) += st33zp24/
> obj-$(CONFIG_TCG_XEN) += xen-tpmfront.o
> obj-$(CONFIG_TCG_CRB) += tpm_crb.o
> obj-$(CONFIG_TCG_VTPM_PROXY) += tpm_vtpm_proxy.o
> +obj-$(CONFIG_TCG_FTPM_TEE) += tpm_ftpm_tee.o
> diff --git a/drivers/char/tpm/tpm_ftpm_tee.c b/drivers/char/tpm/tpm_ftpm_tee.c
> new file mode 100644
> index 000000000000..f33cdfeb5376
> --- /dev/null
> +++ b/drivers/char/tpm/tpm_ftpm_tee.c
> @@ -0,0 +1,366 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) Microsoft Corporation
> + */
There should be at least some description what kind of implementation
this is and something about TEE.
> +
> +#include <linux/of.h>
> +#include <linux/of_platform.h>
> +#include <linux/acpi.h>
> +#include <linux/platform_device.h>
> +#include <linux/tee_drv.h>
> +#include <linux/uuid.h>
> +#include <linux/tpm.h>
> +
> +#include "tpm.h"
> +#include "tpm_ftpm_tee.h"
> +
> +#define DRIVER_NAME "ftpm-tee"
> +
> +/* TA_FTPM_UUID: BC50D971-D4C9-42C4-82CB-343FB7F37896 */
> +static const uuid_t ftpm_ta_uuid =
> + UUID_INIT(0xBC50D971, 0xD4C9, 0x42C4,
> + 0x82, 0xCB, 0x34, 0x3F, 0xB7, 0xF3, 0x78, 0x96);
Just wondering why prefixes are here in different order in the comment
and code.
> +
> +/*
> + * Note: ftpm_tee_tpm_op_recv and ftpm_tee_tpm_op_send are called from the
> + * same routine tpm_try_transmit in tpm-interface.c. These calls are protected
> + * by chip->tpm_mutex => There is no need for protecting any data shared
> + * between these routines ex: struct ftpm_tee_private
> + */
This documentation block should be removed. It could be in all drivers
and thus this documentation belongs outside of specific HW drivers.
> +
> +/**
> + * ftpm_tee_tpm_op_recv retrieve fTPM response.
> + * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h.
> + * @param: buf, the buffer to store data.
> + * @param: count, the number of bytes to read.
> + * @return: In case of success the number of bytes received.
> + * In other case, a < 0 value describing the issue.
> + */
This should be modified to follow kdoc [1]. It is inconsistent with the
other kdoc comments we have. Now it is all wrong and contains redundant
information. It should be something like
/**
* ftpm_tee_tpm_op_recv() - retrieve a response from fTPM
* @chip: TPM chip associated with the fTPM
* @buf: buffer for the received data
* @count: number of bytes to read
*
* Copy the response from fTPM's internal buffer to the buffer provided
* by the caller.
*
* Return:
* 0 on success,
* -errno on error
*/
> +static int ftpm_tee_tpm_op_recv(struct tpm_chip *chip, u8 *buf, size_t count)
> +{
> + struct ftpm_tee_private *pvt_data = dev_get_drvdata(chip->dev.parent);
> + size_t len;
> +
> + len = pvt_data->resp_len;
> + if (count < len) {
> + dev_err(&chip->dev,
> + "%s:Invalid size in recv: count=%zd, resp_len=%zd\n",
> + __func__, count, len);
> + return -EIO;
> + }
> +
> + memcpy(buf, pvt_data->resp_buf, len);
> + pvt_data->resp_len = 0;
> +
> + return len;
> +}
> +
> +/**
> + * ftpm_tee_tpm_op_send send TPM commands through the TEE shared memory.
> + *
> + * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
> + * @param: buf, the buffer to send.
> + * @param: len, the number of bytes to send.
> + * @return: In case of success, returns 0.
> + * In other case, a < 0 value describing the issue.
> + */
This should be modified to follow kdoc [1]. It is inconsistent with the
other kdoc comments we have.
> +static int ftpm_tee_tpm_op_send(struct tpm_chip *chip, u8 *buf, size_t len)
> +{
> + struct ftpm_tee_private *pvt_data = dev_get_drvdata(chip->dev.parent);
> + size_t resp_len;
> + int rc;
> + u8 *temp_buf;
> + struct tpm_header *resp_header;
> + struct tee_ioctl_invoke_arg transceive_args;
> + struct tee_param command_params[4];
> + struct tee_shm *shm = pvt_data->shm;
> +
> + if (len > MAX_COMMAND_SIZE) {
> + dev_err(&chip->dev,
> + "%s:len=%zd exceeds MAX_COMMAND_SIZE supported by fTPM TA\n",
> + __func__, len);
> + return -EIO;
> + }
> +
> + memset(&transceive_args, 0, sizeof(transceive_args));
> + memset(command_params, 0, sizeof(command_params));
> + pvt_data->resp_len = 0;
> +
> + /* Invoke FTPM_OPTEE_TA_SUBMIT_COMMAND function of fTPM TA */
> + transceive_args = (struct tee_ioctl_invoke_arg) {
> + .func = FTPM_OPTEE_TA_SUBMIT_COMMAND,
> + .session = pvt_data->session,
> + .num_params = 4,
> + };
> +
> + /* Fill FTPM_OPTEE_TA_SUBMIT_COMMAND parameters */
> + command_params[0] = (struct tee_param) {
> + .attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT,
> + .u.memref = {
> + .shm = shm,
> + .size = len,
> + .shm_offs = 0,
> + },
> + };
> +
> + temp_buf = tee_shm_get_va(shm, 0);
> + if (IS_ERR(temp_buf)) {
> + dev_err(&chip->dev, "%s:tee_shm_get_va failed for transmit\n",
> + __func__);
> + return PTR_ERR(temp_buf);
> + }
> + memset(temp_buf, 0, (MAX_COMMAND_SIZE + MAX_RESPONSE_SIZE));
> +
> + memcpy(temp_buf, buf, len);
> +
> + command_params[1] = (struct tee_param) {
> + .attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT,
> + .u.memref = {
> + .shm = shm,
> + .size = MAX_RESPONSE_SIZE,
> + .shm_offs = MAX_COMMAND_SIZE,
> + },
> + };
> +
> + rc = tee_client_invoke_func(pvt_data->ctx, &transceive_args,
> + command_params);
> + if ((rc < 0) || (transceive_args.ret != 0)) {
> + dev_err(&chip->dev, "%s:SUBMIT_COMMAND invoke error: 0x%x\n",
> + __func__, transceive_args.ret);
> + return (rc < 0) ? rc : transceive_args.ret;
> + }
> +
> + temp_buf = tee_shm_get_va(shm, command_params[1].u.memref.shm_offs);
> + if (IS_ERR(temp_buf)) {
> + dev_err(&chip->dev, "%s:tee_shm_get_va failed for receive\n",
> + __func__);
> + return PTR_ERR(temp_buf);
> + }
> +
> + resp_header = (struct tpm_header *)temp_buf;
> + resp_len = be32_to_cpu(resp_header->length);
> +
> + /* sanity check resp_len */
> + if (resp_len < TPM_HEADER_SIZE) {
> + dev_err(&chip->dev, "%s:tpm response header too small\n",
> + __func__);
> + return -EIO;
> + }
> + if (resp_len > MAX_RESPONSE_SIZE) {
> + dev_err(&chip->dev,
> + "%s:resp_len=%zd exceeds MAX_RESPONSE_SIZE\n",
> + __func__, resp_len);
> + return -EIO;
> + }
> +
> + /* sanity checks look good, cache the response */
> + memcpy(pvt_data->resp_buf, temp_buf, resp_len);
> + pvt_data->resp_len = resp_len;
> +
> + return 0;
> +}
> +
> +static void ftpm_tee_tpm_op_cancel(struct tpm_chip *chip)
> +{
> + /* not supported */
> +}
> +
> +static u8 ftpm_tee_tpm_op_status(struct tpm_chip *chip)
> +{
> + return 0;
> +}
> +
> +static bool ftpm_tee_tpm_req_canceled(struct tpm_chip *chip, u8 status)
> +{
> + return 0;
> +}
> +
> +static const struct tpm_class_ops ftpm_tee_tpm_ops = {
> + .flags = TPM_OPS_AUTO_STARTUP,
> + .recv = ftpm_tee_tpm_op_recv,
> + .send = ftpm_tee_tpm_op_send,
> + .cancel = ftpm_tee_tpm_op_cancel,
> + .status = ftpm_tee_tpm_op_status,
> + .req_complete_mask = 0,
> + .req_complete_val = 0,
> + .req_canceled = ftpm_tee_tpm_req_canceled,
> +};
> +
> +/*
> + * Check whether this driver supports the fTPM TA in the TEE instance
> + * represented by the params (ver/data) to this function.
> + */
> +static int ftpm_tee_match(struct tee_ioctl_version_data *ver, const void *data)
> +{
> + /*
> + * Currently this driver only support GP Complaint OPTEE based fTPM TA
> + */
> + if ((ver->impl_id == TEE_IMPL_ID_OPTEE) &&
> + (ver->gen_caps & TEE_GEN_CAP_GP))
> + return 1;
> + else
> + return 0;
> +}
> +
> +/*
> + * Undo what has been done in ftpm_tee_probe
> + */
> +static void ftpm_tee_deinit(struct ftpm_tee_private *pvt_data)
> +{
> + /* Release the chip */
> + tpm_chip_unregister(pvt_data->chip);
> +
> + /* frees chip */
> + if (pvt_data->chip)
> + put_device(&pvt_data->chip->dev);
> +
> + if (pvt_data->ctx) {
> + /* Free the shared memory pool */
> + tee_shm_free(pvt_data->shm);
> +
> + /* close the existing session with fTPM TA*/
> + tee_client_close_session(pvt_data->ctx, pvt_data->session);
> +
> + /* close the context with TEE driver */
> + tee_client_close_context(pvt_data->ctx);
> + }
> +
> + /* memory allocated with devm_kzalloc() is freed automatically */
> +}
> +
> +/**
> + * ftpm_tee_probe initialize the fTPM
> + * @param: pdev, the platform_device description.
> + * @return: 0 in case of success.
> + * or a negative value describing the error.
> + */
> +static int ftpm_tee_probe(struct platform_device *pdev)
> +{
> + int rc;
> + struct tpm_chip *chip;
> + struct device *dev = &pdev->dev;
> + struct ftpm_tee_private *pvt_data = NULL;
> + struct tee_ioctl_open_session_arg sess_arg;
> +
> + pvt_data = devm_kzalloc(dev, sizeof(struct ftpm_tee_private),
> + GFP_KERNEL);
> + if (!pvt_data)
> + return -ENOMEM;
> +
> + dev_set_drvdata(dev, pvt_data);
> +
> + /* Open context with TEE driver */
> + pvt_data->ctx = tee_client_open_context(NULL, ftpm_tee_match, NULL,
> + NULL);
> + if (IS_ERR(pvt_data->ctx)) {
> + dev_err(dev, "%s:tee_client_open_context failed\n", __func__);
> + return -EPROBE_DEFER;
> + }
> +
> + /* Open a session with fTPM TA */
> + memset(&sess_arg, 0, sizeof(sess_arg));
> + memcpy(sess_arg.uuid, ftpm_ta_uuid.b, TEE_IOCTL_UUID_LEN);
> + sess_arg.clnt_login = TEE_IOCTL_LOGIN_PUBLIC;
> + sess_arg.num_params = 0;
> +
> + rc = tee_client_open_session(pvt_data->ctx, &sess_arg, NULL);
> + if ((rc < 0) || (sess_arg.ret != 0)) {
> + dev_err(dev, "%s:tee_client_open_session failed, err=%x\n",
> + __func__, sess_arg.ret);
> + rc = -EINVAL;
> + goto out_tee_session;
> + }
> + pvt_data->session = sess_arg.session;
> +
> + /* Allocate dynamic shared memory with fTPM TA */
> + pvt_data->shm = tee_shm_alloc(pvt_data->ctx,
> + (MAX_COMMAND_SIZE + MAX_RESPONSE_SIZE),
> + TEE_SHM_MAPPED | TEE_SHM_DMA_BUF);
> + if (IS_ERR(pvt_data->shm)) {
> + dev_err(dev, "%s:tee_shm_alloc failed\n", __func__);
> + rc = -ENOMEM;
> + goto out_shm_alloc;
> + }
> +
> + /* Allocate new struct tpm_chip instance */
> + chip = tpm_chip_alloc(dev, &ftpm_tee_tpm_ops);
> + if (IS_ERR(chip)) {
> + dev_err(dev, "%s:tpm_chip_alloc failed\n", __func__);
> + rc = PTR_ERR(chip);
> + goto out_chip_alloc;
> + }
> +
> + pvt_data->chip = chip;
> + pvt_data->chip->flags |= TPM_CHIP_FLAG_TPM2;
> +
> + /* Create a character device for the fTPM */
> + rc = tpm_chip_register(pvt_data->chip);
> + if (rc) {
> + dev_err(dev, "%s:tpm_chip_register failed with rc=%d\n",
> + __func__, rc);
> + goto out_chip;
> + }
> +
> + return 0;
> +
> +out_chip:
> + put_device(&pvt_data->chip->dev);
> +out_chip_alloc:
> + tee_shm_free(pvt_data->shm);
> +out_shm_alloc:
> + tee_client_close_session(pvt_data->ctx, pvt_data->session);
> +out_tee_session:
> + tee_client_close_context(pvt_data->ctx);
> +
> + return rc;
> +}
> +
> +/**
> + * ftpm_tee_remove remove the TPM device
> + * @param: pdev, the platform_device description.
> + * @return: 0 in case of success.
> + */
> +static int ftpm_tee_remove(struct platform_device *pdev)
> +{
> + struct ftpm_tee_private *pvt_data = dev_get_drvdata(&pdev->dev);
> +
> + /* Release the chip */
> + tpm_chip_unregister(pvt_data->chip);
> +
> + /* frees chip */
> + put_device(&pvt_data->chip->dev);
> +
> + /* Free the shared memory pool */
> + tee_shm_free(pvt_data->shm);
> +
> + /* close the existing session with fTPM TA*/
> + tee_client_close_session(pvt_data->ctx, pvt_data->session);
> +
> + /* close the context with TEE driver */
> + tee_client_close_context(pvt_data->ctx);
> +
> + /* memory allocated with devm_kzalloc() is freed automatically */
> +
> + return 0;
> +}
> +
> +static const struct of_device_id of_ftpm_tee_ids[] = {
> + { .compatible = "microsoft,ftpm" },
> + { }
> +};
> +MODULE_DEVICE_TABLE(of, of_ftpm_tee_ids);
> +
> +static struct platform_driver ftpm_tee_driver = {
> + .driver = {
> + .name = DRIVER_NAME,
> + .of_match_table = of_match_ptr(of_ftpm_tee_ids),
> + },
> + .probe = ftpm_tee_probe,
> + .remove = ftpm_tee_remove,
> +};
> +
> +module_platform_driver(ftpm_tee_driver);
> +
> +MODULE_AUTHOR("Thirupathaiah Annapureddy <thiruan@microsoft.com>");
> +MODULE_DESCRIPTION("TPM Driver for fTPM TA in TEE");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/char/tpm/tpm_ftpm_tee.h b/drivers/char/tpm/tpm_ftpm_tee.h
> new file mode 100644
> index 000000000000..9de513e72dbb
> --- /dev/null
> +++ b/drivers/char/tpm/tpm_ftpm_tee.h
> @@ -0,0 +1,47 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) Microsoft Corporation
> + */
> +
> +#ifndef __TPM_FTPM_TEE_H__
> +#define __TPM_FTPM_TEE_H__
> +
> +#include <linux/tee_drv.h>
> +#include <linux/uuid.h>
> +#include <linux/tpm.h>
> +
> +/* The TAFs ID implemented in this TA */
> +#define FTPM_OPTEE_TA_SUBMIT_COMMAND (0)
> +#define FTPM_OPTEE_TA_EMULATE_PPI (1)
> +
> +/* max. buffer size supported by fTPM */
> +#define MAX_COMMAND_SIZE 4096
> +#define MAX_RESPONSE_SIZE 4096
> +
> +/**
> + * struct ftpm_tee_private - fTPM's private data
> + * @chip: struct tpm_chip instance registered with tpm framework.
> + * @state: internal state
> + * @session: fTPM TA session identifier.
> + * @resp_len: cached response buffer length.
> + * @resp_buf: cached response buffer.
> + * @ctx: TEE context handler.
> + * @shm: Memory pool shared with fTPM TA in TEE.
> + */
> +struct ftpm_tee_private {
> + struct tpm_chip *chip;
> + u32 session;
> + size_t resp_len;
> + u8 resp_buf[MAX_RESPONSE_SIZE];
> + struct tee_context *ctx;
> + struct tee_shm *shm;
> +};
> +
> +/*
> + * Note: ftpm_tee_tpm_op_recv and ftpm_tee_tpm_op_send are called from the
> + * same routine tpm_try_transmit in tpm-interface.c. These calls are protected
> + * by chip->tpm_mutex => There is no need for protecting any data shared
> + * between these routines ex: struct ftpm_tee_private
> + */
This comment should be removed.
> +
> +#endif /* __TPM_FTPM_TEE_H__ */
> --
> 2.19.1
>
[1] https://www.kernel.org/doc/Documentation/kernel-doc-nano-HOWTO.txt
/Jarkko
^ permalink raw reply
* Re: [PATCH v2 00/17] kunit: introduce KUnit, the Linux kernel unit testing framework
From: Daniel Vetter @ 2019-05-15 7:41 UTC (permalink / raw)
To: Brendan Higgins
Cc: Daniel Vetter, Theodore Ts'o, Frank Rowand, Tim.Bird,
Knut Omang, Greg KH, Kees Cook, Kieran Bingham, Luis R. Rodriguez,
Rob Herring, sboyd, Shuah Khan, devicetree, dri-devel, kunit-dev,
Linux Doc Mailing List, linux-fsdevel, linux-kbuild,
Linux Kernel Mailing List, open list:KERNEL SELFTEST FRAMEWORK,
linux-nvdimm, linux-um, Sasha Levin, Amir Goldstein,
Dan Carpenter, Dan Williams, jdike, Joel Stanley, Julia Lawall,
Kevin Hilman, Logan Gunthorpe, Michael Ellerman, Petr Mladek,
Richard Weinberger, David Rientjes, Steven Rostedt, wfg
In-Reply-To: <20190514183618.GC109557@google.com>
On Tue, May 14, 2019 at 11:36:18AM -0700, Brendan Higgins wrote:
> On Tue, May 14, 2019 at 02:05:05PM +0200, Daniel Vetter wrote:
> > On Tue, May 14, 2019 at 8:04 AM Brendan Higgins
> > <brendanhiggins@google.com> wrote:
> > >
> > > On Mon, May 13, 2019 at 04:44:51PM +0200, Daniel Vetter wrote:
> > > > On Sat, May 11, 2019 at 01:33:44PM -0400, Theodore Ts'o wrote:
> > > > > On Fri, May 10, 2019 at 02:12:40PM -0700, Frank Rowand wrote:
> > > > > > However, the reply is incorrect. Kselftest in-kernel tests (which
> > > > > > is the context here) can be configured as built in instead of as
> > > > > > a module, and built in a UML kernel. The UML kernel can boot,
> > > > > > running the in-kernel tests before UML attempts to invoke the
> > > > > > init process.
> > > > >
> > > > > Um, Citation needed?
> > > > >
> > > > > I don't see any evidence for this in the kselftest documentation, nor
> > > > > do I see any evidence of this in the kselftest Makefiles.
> > > > >
> > > > > There exists test modules in the kernel that run before the init
> > > > > scripts run --- but that's not strictly speaking part of kselftests,
> > > > > and do not have any kind of infrastructure. As noted, the
> > > > > kselftests_harness header file fundamentally assumes that you are
> > > > > running test code in userspace.
> > > >
> > > > Yeah I really like the "no userspace required at all" design of kunit,
> > > > while still collecting results in a well-defined way (unless the current
> > > > self-test that just run when you load the module, with maybe some
> > > > kselftest ad-hoc wrapper around to collect the results).
> > > >
> > > > What I want to do long-term is to run these kernel unit tests as part of
> > > > the build-testing, most likely in gitlab (sooner or later, for drm.git
> > >
> > > Totally! This is part of the reason I have been insisting on a minimum
> > > of UML compatibility for all unit tests. If you can suffiently constrain
> > > the environment that is required for tests to run in, it makes it much
> > > easier not only for a human to run your tests, but it also makes it a
> > > lot easier for an automated service to be able to run your tests.
> > >
> > > I actually have a prototype presubmit already working on my
> > > "stable/non-upstream" branch. You can checkout what presubmit results
> > > look like here[1][2].
> >
> > ug gerrit :-)
>
> Yeah, yeah, I know, but it is a lot easier for me to get a project set
> up here using Gerrit, when we already use that for a lot of other
> projects.
>
> Also, Gerrit has gotten a lot better over the last two years or so. Two
> years ago, I wouldn't touch it with a ten foot pole. It's not so bad
> anymore, at least if you are used to using a web UI to review code.
I was somewhat joking, I'm just not used to gerrit ... And seems to indeed
be a lot more polished than last time I looked at it seriously.
> > > > only ofc). So that people get their pull requests (and patch series, we
> > > > have some ideas to tie this into patchwork) automatically tested for this
> > >
> > > Might that be Snowpatch[3]? I talked to Russell, the creator of Snowpatch,
> > > and he seemed pretty open to collaboration.
> > >
> > > Before I heard about Snowpatch, I had an intern write a translation
> > > layer that made Prow (the presubmit service that I used in the prototype
> > > above) work with LKML[4].
> >
> > There's about 3-4 forks/clones of patchwork. snowpatch is one, we have
> > a different one on freedesktop.org. It's a bit a mess :-/
>
> Oh, I didn't realize that. I found your patchwork instance here[5], but
> do you have a place where I can see the changes you have added to
> support presubmit?
Ok here's a few links. Aside from the usual patch view we've also added a
series view:
https://patchwork.freedesktop.org/project/intel-gfx/series/?ordering=-last_updated
This ties the patches + cover letter together, and it even (tries to at
least) track revisions. Here's an example which is currently at revision
9:
https://patchwork.freedesktop.org/series/57232/
Below the patch list for each revision we also have the test result list.
If you click on the grey bar it'll expand with the summary from CI, the
"See full logs" is link to the full results from our CI. This is driven
with some REST api from our jenkins.
Patchwork also sends out mails for these results.
Source is on gitlab: https://gitlab.freedesktop.org/patchwork-fdo
> > > I am not married to either approach, but I think between the two of
> > > them, most of the initial legwork has been done to make presubmit on
> > > LKML a reality.
> >
> > We do have presubmit CI working already with our freedesktop.org
> > patchwork. The missing glue is just tying that into gitlab CI somehow
> > (since we want to unify build testing more and make it easier for
> > contributors to adjust things).
>
> I checked out a couple of your projects on your patchwork instance: AMD
> X.Org drivers, DRI devel, and Wayland. I saw the tab you added for
> tests, but none of them actually had any test results. Can you point me
> at one that does?
Atm we use the CI stuff only on intel-gfx, with the our gpu CI farm, see
links above.
Cheers, Daniel
>
> Cheers!
>
> [5] https://patchwork.freedesktop.org/
>
> > > > super basic stuff.
> > >
> > > I am really excited to hear back on what you think!
> > >
> > > Cheers!
> > >
> > > [1] https://kunit-review.googlesource.com/c/linux/+/1509/10#message-7bfa40efb132e15c8388755c273837559911425c
> > > [2] https://kunit-review.googlesource.com/c/linux/+/1509/10#message-a6784496eafff442ac98fb068bf1a0f36ee73509
> > > [3] https://developer.ibm.com/open/projects/snowpatch/
> > > [4] https://kunit.googlesource.com/prow-lkml/
> > > _______________________________________________
> > > dri-devel mailing list
> > > dri-devel@lists.freedesktop.org
> > > https://lists.freedesktop.org/mailman/listinfo/dri-devel
>
--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
^ permalink raw reply
* Re: [PATCH v2 00/17] kunit: introduce KUnit, the Linux kernel unit testing framework
From: Theodore Ts'o @ 2019-05-15 4:28 UTC (permalink / raw)
To: Frank Rowand
Cc: Tim.Bird, knut.omang, gregkh, brendanhiggins, keescook,
kieran.bingham, mcgrof, robh, sboyd, shuah, devicetree, dri-devel,
kunit-dev, linux-doc, linux-fsdevel, linux-kbuild, linux-kernel,
linux-kselftest, linux-nvdimm, linux-um, Alexander.Levin,
amir73il, dan.carpenter, dan.j.williams, daniel, jdike, joel,
julia.lawall, khilman, logang, mpe, pmladek, richard, rientjes,
rostedt, wfg
In-Reply-To: <a305c732-9953-8724-b4a4-25aa50c89365@gmail.com>
On Tue, May 14, 2019 at 05:26:47PM -0700, Frank Rowand wrote:
> On 5/11/19 10:33 AM, Theodore Ts'o wrote:
> > On Fri, May 10, 2019 at 02:12:40PM -0700, Frank Rowand wrote:
> >> However, the reply is incorrect. Kselftest in-kernel tests (which
> >> is the context here) can be configured as built in instead of as
> >> a module, and built in a UML kernel. The UML kernel can boot,
> >> running the in-kernel tests before UML attempts to invoke the
> >> init process.
> >
> > Um, Citation needed?
>
> The paragraph that you quoted tells you exactly how to run a kselftest
> in-kernel test in a UML kernel. Just to what that paragraph says.
I didn't quote a paragraph. But I'll quote from it now:
$ make -C tools/testing/selftests run_tests
This runs the kselftest harness, *in userspace*. That means you have
to have a root file system, and it's run after init has started, by
default. You asserted that kselftests allows you to run modules
before init has started. There is absolutely zero, cero, nada, zilch
mentions of any of anything like that in Documentation/dev-tools/kselftests.rst
> > There exists test modules in the kernel that run before the init
> > scripts run --- but that's not strictly speaking part of kselftests,
> > and do not have any kind of infrastructure. As noted, the
> > kselftests_harness header file fundamentally assumes that you are
> > running test code in userspace.
>
> You are ignoring the kselftest in-kernel tests.
I'm talking specifically about what you have been *claiming* to be
kselftest in-kernel tests above. And I'm asserting they are really
not kselftests. They are just ad hoc tests that are run in kernel
space, which, when compiled as modules, can be loaded by a kselftest
shell script. You can certainly hook in these ad hoc in-kernel tests
via kselftests --- but then they aren't run before init starts,
because kselftests is inherently a userspace-driven system.
If you build these tests (many of which existed before kselftests was
merged) into the kernel such that they are run before init starts,
without the kselftest harness, then they are not kselftests, by
definition. Both in how they are run, and since many of these
in-kernel tests predate the introduction of kselftests --- in some
cases, by many years.
> We are talking in circles. I'm done with this thread.
Yes, that sounds like it would be best.
- Ted
^ permalink raw reply
* Re: [PATCH v3 0/2] ftpm: a firmware based TPM driver
From: Sumit Garg @ 2019-05-15 2:02 UTC (permalink / raw)
To: Sasha Levin
Cc: Jarkko Sakkinen, peterhuewe, jgg, corbet,
Linux Kernel Mailing List, linux-doc, linux-integrity,
linux-kernel, thiruan, bryankel
In-Reply-To: <20190514193056.GN11972@sasha-vm>
On Wed, 15 May 2019 at 01:00, Sasha Levin <sashal@kernel.org> wrote:
>
> On Wed, May 08, 2019 at 03:44:36PM +0300, Jarkko Sakkinen wrote:
> >On Tue, May 07, 2019 at 01:40:20PM -0400, Sasha Levin wrote:
> >> On Mon, Apr 15, 2019 at 11:56:34AM -0400, Sasha Levin wrote:
> >> > From: "Sasha Levin (Microsoft)" <sashal@kernel.org>
> >> >
> >> > Changes since v2:
> >> >
> >> > - Drop the devicetree bindings patch (we don't add any new ones).
> >> > - More code cleanups based on Jason Gunthorpe's review.
> >> >
> >> > Sasha Levin (2):
> >> > ftpm: firmware TPM running in TEE
> >> > ftpm: add documentation for ftpm driver
> >>
> >> Ping? Does anyone have any objections to this?
> >
> >Sorry I've been on vacation week before last week and last week
> >I was extremely busy because I had been on vacation. This in
> >my TODO list. Will look into it tomorrow in detail.
> >
> >Apologies for the delay with this!
>
> Hi Jarkko,
>
> If there aren't any big objections to this, can we get it merged in?
> We'll be happy to address any comments that come up.
I guess you have missed or ignored this comment [1]. Please address it.
[1] https://lkml.org/lkml/2019/5/8/11
-Sumit
>
> --
> Thanks,
> Sasha
^ permalink raw reply
* [PATCH v4 1/9] docs: filesystems: vfs: Remove space before tab
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
Currently the file has a bunch of spaces before tabspaces. This is a
nuisance when patching the file because they show up whenever we touch
these lines. Let's just fix them all now in preparation for doing the
RST conversion.
Remove spaces before tabspaces.
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 78 +++++++++++++++----------------
1 file changed, 39 insertions(+), 39 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 761c6fd24a53..637fd1756b89 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -136,7 +136,7 @@ struct file_system_type {
should be shut down
owner: for internal VFS use: you should initialize this to THIS_MODULE in
- most cases.
+ most cases.
next: for internal VFS use: you should initialize this to NULL
@@ -145,7 +145,7 @@ struct file_system_type {
The mount() method has the following arguments:
struct file_system_type *fs_type: describes the filesystem, partly initialized
- by the specific filesystem code
+ by the specific filesystem code
int flags: mount flags
@@ -182,12 +182,12 @@ and provides a fill_super() callback instead. The generic variants are:
mount_nodev: mount a filesystem that is not backed by a device
mount_single: mount a filesystem which shares the instance between
- all mounts
+ all mounts
A fill_super() callback implementation has the following arguments:
struct super_block *sb: the superblock structure. The callback
- must initialize this properly.
+ must initialize this properly.
void *data: arbitrary mount options, usually comes as an ASCII
string (see "Mount Options" section)
@@ -238,14 +238,14 @@ only called from a process context (i.e. not from an interrupt handler
or bottom half).
alloc_inode: this method is called by alloc_inode() to allocate memory
- for struct inode and initialize it. If this function is not
- defined, a simple 'struct inode' is allocated. Normally
- alloc_inode will be used to allocate a larger structure which
- contains a 'struct inode' embedded within it.
+ for struct inode and initialize it. If this function is not
+ defined, a simple 'struct inode' is allocated. Normally
+ alloc_inode will be used to allocate a larger structure which
+ contains a 'struct inode' embedded within it.
destroy_inode: this method is called by destroy_inode() to release
- resources allocated for struct inode. It is only required if
- ->alloc_inode was defined and simply undoes anything done by
+ resources allocated for struct inode. It is only required if
+ ->alloc_inode was defined and simply undoes anything done by
->alloc_inode.
dirty_inode: this method is called by the VFS to mark an inode dirty.
@@ -273,15 +273,15 @@ or bottom half).
(i.e. unmount). This is called with the superblock lock held
sync_fs: called when VFS is writing out all dirty data associated with
- a superblock. The second parameter indicates whether the method
+ a superblock. The second parameter indicates whether the method
should wait until the write out has been completed. Optional.
freeze_fs: called when VFS is locking a filesystem and
- forcing it into a consistent state. This method is currently
- used by the Logical Volume Manager (LVM).
+ forcing it into a consistent state. This method is currently
+ used by the Logical Volume Manager (LVM).
unfreeze_fs: called when VFS is unlocking a filesystem and making it writable
- again.
+ again.
statfs: called when the VFS needs to get filesystem statistics.
@@ -472,30 +472,30 @@ otherwise noted.
that.
permission: called by the VFS to check for access rights on a POSIX-like
- filesystem.
+ filesystem.
May be called in rcu-walk mode (mask & MAY_NOT_BLOCK). If in rcu-walk
- mode, the filesystem must check the permission without blocking or
+ mode, the filesystem must check the permission without blocking or
storing to the inode.
If a situation is encountered that rcu-walk cannot handle, return
-ECHILD and it will be called again in ref-walk mode.
setattr: called by the VFS to set attributes for a file. This method
- is called by chmod(2) and related system calls.
+ is called by chmod(2) and related system calls.
getattr: called by the VFS to get attributes of a file. This method
- is called by stat(2) and related system calls.
+ is called by stat(2) and related system calls.
listxattr: called by the VFS to list all extended attributes for a
given file. This method is called by the listxattr(2) system call.
update_time: called by the VFS to update a specific time or the i_version of
- an inode. If this is not defined the VFS will update the inode itself
- and call mark_inode_dirty_sync.
+ an inode. If this is not defined the VFS will update the inode itself
+ and call mark_inode_dirty_sync.
atomic_open: called on the last component of an open. Using this optional
- method the filesystem can look up, possibly create and open the file in
+ method the filesystem can look up, possibly create and open the file in
one atomic operation. If it wants to leave actual opening to the
caller (e.g. if the file turned out to be a symlink, device, or just
something filesystem won't do atomic open for), it may signal this by
@@ -683,13 +683,13 @@ struct address_space_operations {
that all succeeds, ->readpage will be called again.
writepages: called by the VM to write out pages associated with the
- address_space object. If wbc->sync_mode is WBC_SYNC_ALL, then
- the writeback_control will specify a range of pages that must be
- written out. If it is WBC_SYNC_NONE, then a nr_to_write is given
+ address_space object. If wbc->sync_mode is WBC_SYNC_ALL, then
+ the writeback_control will specify a range of pages that must be
+ written out. If it is WBC_SYNC_NONE, then a nr_to_write is given
and that many pages should be written if possible.
If no ->writepages is given, then mpage_writepages is used
- instead. This will choose pages from the address space that are
- tagged as DIRTY and will pass them to ->writepage.
+ instead. This will choose pages from the address space that are
+ tagged as DIRTY and will pass them to ->writepage.
set_page_dirty: called by the VM to set a page dirty.
This is particularly needed if an address space attaches
@@ -700,11 +700,11 @@ struct address_space_operations {
PAGECACHE_TAG_DIRTY tag in the radix tree.
readpages: called by the VM to read pages associated with the address_space
- object. This is essentially just a vector version of
- readpage. Instead of just one page, several pages are
- requested.
+ object. This is essentially just a vector version of
+ readpage. Instead of just one page, several pages are
+ requested.
readpages is only used for read-ahead, so read errors are
- ignored. If anything goes wrong, feel free to give up.
+ ignored. If anything goes wrong, feel free to give up.
write_begin:
Called by the generic buffered write code to ask the filesystem to
@@ -741,12 +741,12 @@ struct address_space_operations {
that were able to be copied into pagecache.
bmap: called by the VFS to map a logical block offset within object to
- physical block number. This method is used by the FIBMAP
- ioctl and for working with swap-files. To be able to swap to
- a file, the file must have a stable mapping to a block
- device. The swap system does not go through the filesystem
- but instead uses bmap to find out where the blocks in the file
- are and uses those addresses directly.
+ physical block number. This method is used by the FIBMAP
+ ioctl and for working with swap-files. To be able to swap to
+ a file, the file must have a stable mapping to a block
+ device. The swap system does not go through the filesystem
+ but instead uses bmap to find out where the blocks in the file
+ are and uses those addresses directly.
invalidatepage: If a page has PagePrivate set, then invalidatepage
will be called when part or all of the page is to be removed
@@ -806,7 +806,7 @@ struct address_space_operations {
putback_page: Called by the VM when isolated page's migration fails.
launder_page: Called before freeing a page - it writes back the dirty page. To
- prevent redirtying the page, it is kept locked during the whole
+ prevent redirtying the page, it is kept locked during the whole
operation.
is_partially_uptodate: Called by the VM when reading a file through the
@@ -917,7 +917,7 @@ otherwise noted.
unlocked_ioctl: called by the ioctl(2) system call.
compat_ioctl: called by the ioctl(2) system call when 32 bit system calls
- are used on 64 bit kernels.
+ are used on 64 bit kernels.
mmap: called by the mmap(2) system call
@@ -942,7 +942,7 @@ otherwise noted.
(non-blocking) mode is enabled for a file
lock: called by the fcntl(2) system call for F_GETLK, F_SETLK, and F_SETLKW
- commands
+ commands
get_unmapped_area: called by the mmap(2) system call
--
2.21.0
^ permalink raw reply related
* [PATCH v4 5/9] docs: filesystems: vfs: Use correct initial heading
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
Kernel RST has a preferred heading adornment scheme. Currently all the
heading adornments follow this scheme except the document heading.
Use correct heading adornment for initial heading.
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index ed12d28bda62..790feccca5f4 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -1,5 +1,6 @@
-
- Overview of the Linux Virtual File System
+=========================================
+Overview of the Linux Virtual File System
+=========================================
Original author: Richard Gooch <rgooch@atnf.csiro.au>
--
2.21.0
^ permalink raw reply related
* [PATCH v4 4/9] docs: filesystems: vfs: Use uniform spacing around headings
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
Currently spacing before and after headings is non-uniform. Use two
blank lines before a heading and one after the heading.
Use uniform spacing around headings.
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 14839bc84d38..ed12d28bda62 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -321,6 +321,7 @@ Whoever sets up the inode is responsible for filling in the "i_op"
field. This is a pointer to a "struct inode_operations" which describes
the methods that can be performed on individual inodes.
+
struct xattr_handlers
---------------------
@@ -507,6 +508,7 @@ otherwise noted.
tmpfile: called in the end of O_TMPFILE open(). Optional, equivalent to
atomically creating, opening and unlinking a file in given directory.
+
The Address Space Object
========================
@@ -580,8 +582,10 @@ and the constraints under which it is being done. It is also used to
return information back to the caller about the result of a writepage or
writepages request.
+
Handling errors during writeback
--------------------------------
+
Most applications that do buffered I/O will periodically call a file
synchronization call (fsync, fdatasync, msync or sync_file_range) to
ensure that data written has made it to the backing store. When there
@@ -612,6 +616,7 @@ file->fsync operation, they should call file_check_and_advance_wb_err to
ensure that the struct file's error cursor has advanced to the correct
point in the stream of errors emitted by the backing device(s).
+
struct address_space_operations
-------------------------------
@@ -1203,9 +1208,11 @@ manipulate dentries:
and the dentry is returned. The caller must use dput()
to free the dentry when it finishes using it.
+
Mount Options
=============
+
Parsing options
---------------
@@ -1220,6 +1227,7 @@ The <linux/parser.h> header defines an API that helps parse these
options. There are plenty of examples on how to use it in existing
filesystems.
+
Showing options
---------------
@@ -1241,6 +1249,7 @@ The underlying reason for the above rules is to make sure, that a mount
can be accurately replicated (e.g. umounting and mounting again) based
on the information found in /proc/mounts.
+
Resources
=========
--
2.21.0
^ permalink raw reply related
* [PATCH v4 3/9] docs: filesystems: vfs: Use 72 character column width
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
In preparation for conversion to RST format use the kernels favoured
documentation column width. If we are going to do this we might as well
do it thoroughly. Just do the paragraphs (not the indented stuff), the
rest will be done during indentation fix up patch.
This patch is whitespace only, no textual changes.
Use 72 character column width for all paragraph sections.
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 198 +++++++++++++++---------------
1 file changed, 97 insertions(+), 101 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 2a610b9355e0..14839bc84d38 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -14,15 +14,14 @@
Introduction
============
-The Virtual File System (also known as the Virtual Filesystem Switch)
-is the software layer in the kernel that provides the filesystem
-interface to userspace programs. It also provides an abstraction
-within the kernel which allows different filesystem implementations to
-coexist.
+The Virtual File System (also known as the Virtual Filesystem Switch) is
+the software layer in the kernel that provides the filesystem interface
+to userspace programs. It also provides an abstraction within the
+kernel which allows different filesystem implementations to coexist.
-VFS system calls open(2), stat(2), read(2), write(2), chmod(2) and so
-on are called from a process context. Filesystem locking is described
-in the document Documentation/filesystems/Locking.
+VFS system calls open(2), stat(2), read(2), write(2), chmod(2) and so on
+are called from a process context. Filesystem locking is described in
+the document Documentation/filesystems/Locking.
Directory Entry Cache (dcache)
@@ -36,11 +35,10 @@ translate a pathname (filename) into a specific dentry. Dentries live
in RAM and are never saved to disc: they exist only for performance.
The dentry cache is meant to be a view into your entire filespace. As
-most computers cannot fit all dentries in the RAM at the same time,
-some bits of the cache are missing. In order to resolve your pathname
-into a dentry, the VFS may have to resort to creating dentries along
-the way, and then loading the inode. This is done by looking up the
-inode.
+most computers cannot fit all dentries in the RAM at the same time, some
+bits of the cache are missing. In order to resolve your pathname into a
+dentry, the VFS may have to resort to creating dentries along the way,
+and then loading the inode. This is done by looking up the inode.
The Inode Object
@@ -48,33 +46,32 @@ The Inode Object
An individual dentry usually has a pointer to an inode. Inodes are
filesystem objects such as regular files, directories, FIFOs and other
-beasts. They live either on the disc (for block device filesystems)
-or in the memory (for pseudo filesystems). Inodes that live on the
-disc are copied into the memory when required and changes to the inode
-are written back to disc. A single inode can be pointed to by multiple
+beasts. They live either on the disc (for block device filesystems) or
+in the memory (for pseudo filesystems). Inodes that live on the disc
+are copied into the memory when required and changes to the inode are
+written back to disc. A single inode can be pointed to by multiple
dentries (hard links, for example, do this).
To look up an inode requires that the VFS calls the lookup() method of
the parent directory inode. This method is installed by the specific
-filesystem implementation that the inode lives in. Once the VFS has
-the required dentry (and hence the inode), we can do all those boring
-things like open(2) the file, or stat(2) it to peek at the inode
-data. The stat(2) operation is fairly simple: once the VFS has the
-dentry, it peeks at the inode data and passes some of it back to
-userspace.
+filesystem implementation that the inode lives in. Once the VFS has the
+required dentry (and hence the inode), we can do all those boring things
+like open(2) the file, or stat(2) it to peek at the inode data. The
+stat(2) operation is fairly simple: once the VFS has the dentry, it
+peeks at the inode data and passes some of it back to userspace.
The File Object
---------------
Opening a file requires another operation: allocation of a file
-structure (this is the kernel-side implementation of file
-descriptors). The freshly allocated file structure is initialized with
-a pointer to the dentry and a set of file operation member functions.
-These are taken from the inode data. The open() file method is then
-called so the specific filesystem implementation can do its work. You
-can see that this is another switch performed by the VFS. The file
-structure is placed into the file descriptor table for the process.
+structure (this is the kernel-side implementation of file descriptors).
+The freshly allocated file structure is initialized with a pointer to
+the dentry and a set of file operation member functions. These are
+taken from the inode data. The open() file method is then called so the
+specific filesystem implementation can do its work. You can see that
+this is another switch performed by the VFS. The file structure is
+placed into the file descriptor table for the process.
Reading, writing and closing files (and other assorted VFS operations)
is done by using the userspace file descriptor to grab the appropriate
@@ -95,11 +92,12 @@ functions:
extern int unregister_filesystem(struct file_system_type *);
The passed struct file_system_type describes your filesystem. When a
-request is made to mount a filesystem onto a directory in your namespace,
-the VFS will call the appropriate mount() method for the specific
-filesystem. New vfsmount referring to the tree returned by ->mount()
-will be attached to the mountpoint, so that when pathname resolution
-reaches the mountpoint it will jump into the root of that vfsmount.
+request is made to mount a filesystem onto a directory in your
+namespace, the VFS will call the appropriate mount() method for the
+specific filesystem. New vfsmount referring to the tree returned by
+->mount() will be attached to the mountpoint, so that when pathname
+resolution reaches the mountpoint it will jump into the root of that
+vfsmount.
You can see all filesystems that are registered to the kernel in the
file /proc/filesystems.
@@ -158,21 +156,21 @@ The mount() method must return the root dentry of the tree requested by
caller. An active reference to its superblock must be grabbed and the
superblock must be locked. On failure it should return ERR_PTR(error).
-The arguments match those of mount(2) and their interpretation
-depends on filesystem type. E.g. for block filesystems, dev_name is
-interpreted as block device name, that device is opened and if it
-contains a suitable filesystem image the method creates and initializes
-struct super_block accordingly, returning its root dentry to caller.
+The arguments match those of mount(2) and their interpretation depends
+on filesystem type. E.g. for block filesystems, dev_name is interpreted
+as block device name, that device is opened and if it contains a
+suitable filesystem image the method creates and initializes struct
+super_block accordingly, returning its root dentry to caller.
->mount() may choose to return a subtree of existing filesystem - it
doesn't have to create a new one. The main result from the caller's
-point of view is a reference to dentry at the root of (sub)tree to
-be attached; creation of new superblock is a common side effect.
+point of view is a reference to dentry at the root of (sub)tree to be
+attached; creation of new superblock is a common side effect.
-The most interesting member of the superblock structure that the
-mount() method fills in is the "s_op" field. This is a pointer to
-a "struct super_operations" which describes the next level of the
-filesystem implementation.
+The most interesting member of the superblock structure that the mount()
+method fills in is the "s_op" field. This is a pointer to a "struct
+super_operations" which describes the next level of the filesystem
+implementation.
Usually, a filesystem uses one of the generic mount() implementations
and provides a fill_super() callback instead. The generic variants are:
@@ -319,16 +317,16 @@ or bottom half).
implementations will cause holdoff problems due to large scan batch
sizes.
-Whoever sets up the inode is responsible for filling in the "i_op" field. This
-is a pointer to a "struct inode_operations" which describes the methods that
-can be performed on individual inodes.
+Whoever sets up the inode is responsible for filling in the "i_op"
+field. This is a pointer to a "struct inode_operations" which describes
+the methods that can be performed on individual inodes.
struct xattr_handlers
---------------------
On filesystems that support extended attributes (xattrs), the s_xattr
-superblock field points to a NULL-terminated array of xattr handlers. Extended
-attributes are name:value pairs.
+superblock field points to a NULL-terminated array of xattr handlers.
+Extended attributes are name:value pairs.
name: Indicates that the handler matches attributes with the specified name
(such as "system.posix_acl_access"); the prefix field must be NULL.
@@ -348,9 +346,9 @@ attributes are name:value pairs.
attribute. This method is called by the the setxattr(2) and
removexattr(2) system calls.
-When none of the xattr handlers of a filesystem match the specified attribute
-name or when a filesystem doesn't support extended attributes, the various
-*xattr(2) system calls return -EOPNOTSUPP.
+When none of the xattr handlers of a filesystem match the specified
+attribute name or when a filesystem doesn't support extended attributes,
+the various *xattr(2) system calls return -EOPNOTSUPP.
The Inode Object
@@ -362,8 +360,8 @@ An inode object represents an object within the filesystem.
struct inode_operations
-----------------------
-This describes how the VFS can manipulate an inode in your
-filesystem. As of kernel 2.6.22, the following members are defined:
+This describes how the VFS can manipulate an inode in your filesystem.
+As of kernel 2.6.22, the following members are defined:
struct inode_operations {
int (*create) (struct inode *,struct dentry *, umode_t, bool);
@@ -513,42 +511,40 @@ The Address Space Object
========================
The address space object is used to group and manage pages in the page
-cache. It can be used to keep track of the pages in a file (or
-anything else) and also track the mapping of sections of the file into
-process address spaces.
+cache. It can be used to keep track of the pages in a file (or anything
+else) and also track the mapping of sections of the file into process
+address spaces.
There are a number of distinct yet related services that an
-address-space can provide. These include communicating memory
-pressure, page lookup by address, and keeping track of pages tagged as
-Dirty or Writeback.
+address-space can provide. These include communicating memory pressure,
+page lookup by address, and keeping track of pages tagged as Dirty or
+Writeback.
The first can be used independently to the others. The VM can try to
-either write dirty pages in order to clean them, or release clean
-pages in order to reuse them. To do this it can call the ->writepage
-method on dirty pages, and ->releasepage on clean pages with
-PagePrivate set. Clean pages without PagePrivate and with no external
-references will be released without notice being given to the
-address_space.
+either write dirty pages in order to clean them, or release clean pages
+in order to reuse them. To do this it can call the ->writepage method
+on dirty pages, and ->releasepage on clean pages with PagePrivate set.
+Clean pages without PagePrivate and with no external references will be
+released without notice being given to the address_space.
To achieve this functionality, pages need to be placed on an LRU with
-lru_cache_add and mark_page_active needs to be called whenever the
-page is used.
+lru_cache_add and mark_page_active needs to be called whenever the page
+is used.
Pages are normally kept in a radix tree index by ->index. This tree
-maintains information about the PG_Dirty and PG_Writeback status of
-each page, so that pages with either of these flags can be found
-quickly.
+maintains information about the PG_Dirty and PG_Writeback status of each
+page, so that pages with either of these flags can be found quickly.
The Dirty tag is primarily used by mpage_writepages - the default
->writepages method. It uses the tag to find dirty pages to call
->writepage on. If mpage_writepages is not used (i.e. the address
-provides its own ->writepages) , the PAGECACHE_TAG_DIRTY tag is
-almost unused. write_inode_now and sync_inode do use it (through
+provides its own ->writepages) , the PAGECACHE_TAG_DIRTY tag is almost
+unused. write_inode_now and sync_inode do use it (through
__sync_single_inode) to check if ->writepages has been successful in
writing out the whole address_space.
-The Writeback tag is used by filemap*wait* and sync_page* functions,
-via filemap_fdatawait_range, to wait for all writeback to complete.
+The Writeback tag is used by filemap*wait* and sync_page* functions, via
+filemap_fdatawait_range, to wait for all writeback to complete.
An address_space handler may attach extra information to a page,
typically using the 'private' field in the 'struct page'. If such
@@ -558,25 +554,24 @@ handler to deal with that data.
An address space acts as an intermediate between storage and
application. Data is read into the address space a whole page at a
-time, and provided to the application either by copying of the page,
-or by memory-mapping the page.
-Data is written into the address space by the application, and then
-written-back to storage typically in whole pages, however the
-address_space has finer control of write sizes.
+time, and provided to the application either by copying of the page, or
+by memory-mapping the page. Data is written into the address space by
+the application, and then written-back to storage typically in whole
+pages, however the address_space has finer control of write sizes.
The read process essentially only requires 'readpage'. The write
process is more complicated and uses write_begin/write_end or
-set_page_dirty to write data into the address_space, and writepage
-and writepages to writeback data to storage.
+set_page_dirty to write data into the address_space, and writepage and
+writepages to writeback data to storage.
Adding and removing pages to/from an address_space is protected by the
inode's i_mutex.
When data is written to a page, the PG_Dirty flag should be set. It
typically remains set until writepage asks for it to be written. This
-should clear PG_Dirty and set PG_Writeback. It can be actually
-written at any point after PG_Dirty is clear. Once it is known to be
-safe, PG_Writeback is cleared.
+should clear PG_Dirty and set PG_Writeback. It can be actually written
+at any point after PG_Dirty is clear. Once it is known to be safe,
+PG_Writeback is cleared.
Writeback makes use of a writeback_control structure to direct the
operations. This gives the the writepage and writepages operations some
@@ -605,9 +600,10 @@ file descriptors should get back an error is not possible.
Instead, the generic writeback error tracking infrastructure in the
kernel settles for reporting errors to fsync on all file descriptions
that were open at the time that the error occurred. In a situation with
-multiple writers, all of them will get back an error on a subsequent fsync,
-even if all of the writes done through that particular file descriptor
-succeeded (or even if there were no writes on that file descriptor at all).
+multiple writers, all of them will get back an error on a subsequent
+fsync, even if all of the writes done through that particular file
+descriptor succeeded (or even if there were no writes on that file
+descriptor at all).
Filesystems that wish to use this infrastructure should call
mapping_set_error to record the error in the address_space when it
@@ -619,8 +615,8 @@ point in the stream of errors emitted by the backing device(s).
struct address_space_operations
-------------------------------
-This describes how the VFS can manipulate mapping of a file to page cache in
-your filesystem. The following members are defined:
+This describes how the VFS can manipulate mapping of a file to page
+cache in your filesystem. The following members are defined:
struct address_space_operations {
int (*writepage)(struct page *page, struct writeback_control *wbc);
@@ -1227,8 +1223,8 @@ filesystems.
Showing options
---------------
-If a filesystem accepts mount options, it must define show_options()
-to show all the currently active options. The rules are:
+If a filesystem accepts mount options, it must define show_options() to
+show all the currently active options. The rules are:
- options MUST be shown which are not default or their values differ
from the default
@@ -1236,14 +1232,14 @@ to show all the currently active options. The rules are:
- options MAY be shown which are enabled by default or have their
default value
-Options used only internally between a mount helper and the kernel
-(such as file descriptors), or which only have an effect during the
-mounting (such as ones controlling the creation of a journal) are exempt
-from the above rules.
+Options used only internally between a mount helper and the kernel (such
+as file descriptors), or which only have an effect during the mounting
+(such as ones controlling the creation of a journal) are exempt from the
+above rules.
-The underlying reason for the above rules is to make sure, that a
-mount can be accurately replicated (e.g. umounting and mounting again)
-based on the information found in /proc/mounts.
+The underlying reason for the above rules is to make sure, that a mount
+can be accurately replicated (e.g. umounting and mounting again) based
+on the information found in /proc/mounts.
Resources
=========
--
2.21.0
^ permalink raw reply related
* [PATCH v4 2/9] docs: filesystems: vfs: Use uniform space after period.
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
Currently sometimes document has a single space after a period and
sometimes it has double. Whichever we use it should be uniform.
Use double space after period, be uniform.
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 246 +++++++++++++++---------------
1 file changed, 123 insertions(+), 123 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 637fd1756b89..2a610b9355e0 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -16,12 +16,12 @@ Introduction
The Virtual File System (also known as the Virtual Filesystem Switch)
is the software layer in the kernel that provides the filesystem
-interface to userspace programs. It also provides an abstraction
+interface to userspace programs. It also provides an abstraction
within the kernel which allows different filesystem implementations to
coexist.
VFS system calls open(2), stat(2), read(2), write(2), chmod(2) and so
-on are called from a process context. Filesystem locking is described
+on are called from a process context. Filesystem locking is described
in the document Documentation/filesystems/Locking.
@@ -29,37 +29,37 @@ Directory Entry Cache (dcache)
------------------------------
The VFS implements the open(2), stat(2), chmod(2), and similar system
-calls. The pathname argument that is passed to them is used by the VFS
+calls. The pathname argument that is passed to them is used by the VFS
to search through the directory entry cache (also known as the dentry
-cache or dcache). This provides a very fast look-up mechanism to
-translate a pathname (filename) into a specific dentry. Dentries live
+cache or dcache). This provides a very fast look-up mechanism to
+translate a pathname (filename) into a specific dentry. Dentries live
in RAM and are never saved to disc: they exist only for performance.
-The dentry cache is meant to be a view into your entire filespace. As
+The dentry cache is meant to be a view into your entire filespace. As
most computers cannot fit all dentries in the RAM at the same time,
-some bits of the cache are missing. In order to resolve your pathname
+some bits of the cache are missing. In order to resolve your pathname
into a dentry, the VFS may have to resort to creating dentries along
-the way, and then loading the inode. This is done by looking up the
+the way, and then loading the inode. This is done by looking up the
inode.
The Inode Object
----------------
-An individual dentry usually has a pointer to an inode. Inodes are
+An individual dentry usually has a pointer to an inode. Inodes are
filesystem objects such as regular files, directories, FIFOs and other
beasts. They live either on the disc (for block device filesystems)
-or in the memory (for pseudo filesystems). Inodes that live on the
+or in the memory (for pseudo filesystems). Inodes that live on the
disc are copied into the memory when required and changes to the inode
-are written back to disc. A single inode can be pointed to by multiple
+are written back to disc. A single inode can be pointed to by multiple
dentries (hard links, for example, do this).
To look up an inode requires that the VFS calls the lookup() method of
-the parent directory inode. This method is installed by the specific
-filesystem implementation that the inode lives in. Once the VFS has
+the parent directory inode. This method is installed by the specific
+filesystem implementation that the inode lives in. Once the VFS has
the required dentry (and hence the inode), we can do all those boring
things like open(2) the file, or stat(2) it to peek at the inode
-data. The stat(2) operation is fairly simple: once the VFS has the
+data. The stat(2) operation is fairly simple: once the VFS has the
dentry, it peeks at the inode data and passes some of it back to
userspace.
@@ -69,17 +69,17 @@ The File Object
Opening a file requires another operation: allocation of a file
structure (this is the kernel-side implementation of file
-descriptors). The freshly allocated file structure is initialized with
+descriptors). The freshly allocated file structure is initialized with
a pointer to the dentry and a set of file operation member functions.
-These are taken from the inode data. The open() file method is then
-called so the specific filesystem implementation can do its work. You
-can see that this is another switch performed by the VFS. The file
+These are taken from the inode data. The open() file method is then
+called so the specific filesystem implementation can do its work. You
+can see that this is another switch performed by the VFS. The file
structure is placed into the file descriptor table for the process.
Reading, writing and closing files (and other assorted VFS operations)
is done by using the userspace file descriptor to grab the appropriate
file structure, and then calling the required file structure method to
-do whatever is required. For as long as the file is open, it keeps the
+do whatever is required. For as long as the file is open, it keeps the
dentry in use, which in turn means that the VFS inode is still in use.
@@ -94,7 +94,7 @@ functions:
extern int register_filesystem(struct file_system_type *);
extern int unregister_filesystem(struct file_system_type *);
-The passed struct file_system_type describes your filesystem. When a
+The passed struct file_system_type describes your filesystem. When a
request is made to mount a filesystem onto a directory in your namespace,
the VFS will call the appropriate mount() method for the specific
filesystem. New vfsmount referring to the tree returned by ->mount()
@@ -108,7 +108,7 @@ file /proc/filesystems.
struct file_system_type
-----------------------
-This describes the filesystem. As of kernel 2.6.39, the following
+This describes the filesystem. As of kernel 2.6.39, the following
members are defined:
struct file_system_type {
@@ -170,12 +170,12 @@ point of view is a reference to dentry at the root of (sub)tree to
be attached; creation of new superblock is a common side effect.
The most interesting member of the superblock structure that the
-mount() method fills in is the "s_op" field. This is a pointer to
+mount() method fills in is the "s_op" field. This is a pointer to
a "struct super_operations" which describes the next level of the
filesystem implementation.
Usually, a filesystem uses one of the generic mount() implementations
-and provides a fill_super() callback instead. The generic variants are:
+and provides a fill_super() callback instead. The generic variants are:
mount_bdev: mount a filesystem residing on a block device
@@ -186,7 +186,7 @@ and provides a fill_super() callback instead. The generic variants are:
A fill_super() callback implementation has the following arguments:
- struct super_block *sb: the superblock structure. The callback
+ struct super_block *sb: the superblock structure. The callback
must initialize this properly.
void *data: arbitrary mount options, usually comes as an ASCII
@@ -205,7 +205,7 @@ struct super_operations
-----------------------
This describes how the VFS can manipulate the superblock of your
-filesystem. As of kernel 2.6.22, the following members are defined:
+filesystem. As of kernel 2.6.22, the following members are defined:
struct super_operations {
struct inode *(*alloc_inode)(struct super_block *sb);
@@ -233,7 +233,7 @@ struct super_operations {
};
All methods are called without any locks being held, unless otherwise
-noted. This means that most methods can block safely. All methods are
+noted. This means that most methods can block safely. All methods are
only called from a process context (i.e. not from an interrupt handler
or bottom half).
@@ -270,11 +270,11 @@ or bottom half).
delete_inode: called when the VFS wants to delete an inode
put_super: called when the VFS wishes to free the superblock
- (i.e. unmount). This is called with the superblock lock held
+ (i.e. unmount). This is called with the superblock lock held
sync_fs: called when VFS is writing out all dirty data associated with
- a superblock. The second parameter indicates whether the method
- should wait until the write out has been completed. Optional.
+ a superblock. The second parameter indicates whether the method
+ should wait until the write out has been completed. Optional.
freeze_fs: called when VFS is locking a filesystem and
forcing it into a consistent state. This method is currently
@@ -285,10 +285,10 @@ or bottom half).
statfs: called when the VFS needs to get filesystem statistics.
- remount_fs: called when the filesystem is remounted. This is called
+ remount_fs: called when the filesystem is remounted. This is called
with the kernel lock held
- clear_inode: called then the VFS clears the inode. Optional
+ clear_inode: called then the VFS clears the inode. Optional
umount_begin: called when the VFS is unmounting a filesystem.
@@ -309,17 +309,17 @@ or bottom half).
implement ->nr_cached_objects for it to be called correctly.
We can't do anything with any errors that the filesystem might
- encountered, hence the void return type. This will never be called if
+ encountered, hence the void return type. This will never be called if
the VM is trying to reclaim under GFP_NOFS conditions, hence this
method does not need to handle that situation itself.
Implementations must include conditional reschedule calls inside any
- scanning loop that is done. This allows the VFS to determine
+ scanning loop that is done. This allows the VFS to determine
appropriate scan batch sizes without having to worry about whether
implementations will cause holdoff problems due to large scan batch
sizes.
-Whoever sets up the inode is responsible for filling in the "i_op" field. This
+Whoever sets up the inode is responsible for filling in the "i_op" field. This
is a pointer to a "struct inode_operations" which describes the methods that
can be performed on individual inodes.
@@ -363,7 +363,7 @@ struct inode_operations
-----------------------
This describes how the VFS can manipulate an inode in your
-filesystem. As of kernel 2.6.22, the following members are defined:
+filesystem. As of kernel 2.6.22, the following members are defined:
struct inode_operations {
int (*create) (struct inode *,struct dentry *, umode_t, bool);
@@ -393,19 +393,19 @@ struct inode_operations {
Again, all methods are called without any locks being held, unless
otherwise noted.
- create: called by the open(2) and creat(2) system calls. Only
- required if you want to support regular files. The dentry you
+ create: called by the open(2) and creat(2) system calls. Only
+ required if you want to support regular files. The dentry you
get should not have an inode (i.e. it should be a negative
- dentry). Here you will probably call d_instantiate() with the
+ dentry). Here you will probably call d_instantiate() with the
dentry and the newly created inode
lookup: called when the VFS needs to look up an inode in a parent
- directory. The name to look for is found in the dentry. This
+ directory. The name to look for is found in the dentry. This
method must call d_add() to insert the found inode into the
- dentry. The "i_count" field in the inode structure should be
- incremented. If the named inode does not exist a NULL inode
+ dentry. The "i_count" field in the inode structure should be
+ incremented. If the named inode does not exist a NULL inode
should be inserted into the dentry (this is called a negative
- dentry). Returning an error code from this routine must only
+ dentry). Returning an error code from this routine must only
be done on a real error, otherwise creating inodes with system
calls like create(2), mknod(2), mkdir(2) and so on will fail.
If you wish to overload the dentry methods then you should
@@ -413,27 +413,27 @@ otherwise noted.
to a struct "dentry_operations".
This method is called with the directory inode semaphore held
- link: called by the link(2) system call. Only required if you want
- to support hard links. You will probably need to call
+ link: called by the link(2) system call. Only required if you want
+ to support hard links. You will probably need to call
d_instantiate() just as you would in the create() method
- unlink: called by the unlink(2) system call. Only required if you
+ unlink: called by the unlink(2) system call. Only required if you
want to support deleting inodes
- symlink: called by the symlink(2) system call. Only required if you
- want to support symlinks. You will probably need to call
+ symlink: called by the symlink(2) system call. Only required if you
+ want to support symlinks. You will probably need to call
d_instantiate() just as you would in the create() method
- mkdir: called by the mkdir(2) system call. Only required if you want
- to support creating subdirectories. You will probably need to
+ mkdir: called by the mkdir(2) system call. Only required if you want
+ to support creating subdirectories. You will probably need to
call d_instantiate() just as you would in the create() method
- rmdir: called by the rmdir(2) system call. Only required if you want
+ rmdir: called by the rmdir(2) system call. Only required if you want
to support deleting subdirectories
mknod: called by the mknod(2) system call to create a device (char,
- block) inode or a named pipe (FIFO) or socket. Only required
- if you want to support creating these types of inodes. You
+ block) inode or a named pipe (FIFO) or socket. Only required
+ if you want to support creating these types of inodes. You
will probably need to call d_instantiate() just as you would
in the create() method
@@ -474,21 +474,21 @@ otherwise noted.
permission: called by the VFS to check for access rights on a POSIX-like
filesystem.
- May be called in rcu-walk mode (mask & MAY_NOT_BLOCK). If in rcu-walk
- mode, the filesystem must check the permission without blocking or
+ May be called in rcu-walk mode (mask & MAY_NOT_BLOCK). If in rcu-walk
+ mode, the filesystem must check the permission without blocking or
storing to the inode.
If a situation is encountered that rcu-walk cannot handle, return
-ECHILD and it will be called again in ref-walk mode.
- setattr: called by the VFS to set attributes for a file. This method
+ setattr: called by the VFS to set attributes for a file. This method
is called by chmod(2) and related system calls.
- getattr: called by the VFS to get attributes of a file. This method
+ getattr: called by the VFS to get attributes of a file. This method
is called by stat(2) and related system calls.
listxattr: called by the VFS to list all extended attributes for a
- given file. This method is called by the listxattr(2) system call.
+ given file. This method is called by the listxattr(2) system call.
update_time: called by the VFS to update a specific time or the i_version of
an inode. If this is not defined the VFS will update the inode itself
@@ -526,7 +526,7 @@ The first can be used independently to the others. The VM can try to
either write dirty pages in order to clean them, or release clean
pages in order to reuse them. To do this it can call the ->writepage
method on dirty pages, and ->releasepage on clean pages with
-PagePrivate set. Clean pages without PagePrivate and with no external
+PagePrivate set. Clean pages without PagePrivate and with no external
references will be released without notice being given to the
address_space.
@@ -534,7 +534,7 @@ To achieve this functionality, pages need to be placed on an LRU with
lru_cache_add and mark_page_active needs to be called whenever the
page is used.
-Pages are normally kept in a radix tree index by ->index. This tree
+Pages are normally kept in a radix tree index by ->index. This tree
maintains information about the PG_Dirty and PG_Writeback status of
each page, so that pages with either of these flags can be found
quickly.
@@ -620,7 +620,7 @@ struct address_space_operations
-------------------------------
This describes how the VFS can manipulate mapping of a file to page cache in
-your filesystem. The following members are defined:
+your filesystem. The following members are defined:
struct address_space_operations {
int (*writepage)(struct page *page, struct writeback_control *wbc);
@@ -700,7 +700,7 @@ struct address_space_operations {
PAGECACHE_TAG_DIRTY tag in the radix tree.
readpages: called by the VM to read pages associated with the address_space
- object. This is essentially just a vector version of
+ object. This is essentially just a vector version of
readpage. Instead of just one page, several pages are
requested.
readpages is only used for read-ahead, so read errors are
@@ -708,7 +708,7 @@ struct address_space_operations {
write_begin:
Called by the generic buffered write code to ask the filesystem to
- prepare to write len bytes at the given offset in the file. The
+ prepare to write len bytes at the given offset in the file. The
address_space should check that the write will be able to complete,
by allocating space if necessary and doing any other internal
housekeeping. If the write will update parts of any basic-blocks on
@@ -731,7 +731,7 @@ struct address_space_operations {
which case write_end is not called.
write_end: After a successful write_begin, and data copy, write_end must
- be called. len is the original len passed to write_begin, and copied
+ be called. len is the original len passed to write_begin, and copied
is the amount that was able to be copied.
The filesystem must take care of unlocking the page and releasing it
@@ -741,7 +741,7 @@ struct address_space_operations {
that were able to be copied into pagecache.
bmap: called by the VFS to map a logical block offset within object to
- physical block number. This method is used by the FIBMAP
+ physical block number. This method is used by the FIBMAP
ioctl and for working with swap-files. To be able to swap to
a file, the file must have a stable mapping to a block
device. The swap system does not go through the filesystem
@@ -753,7 +753,7 @@ struct address_space_operations {
from the address space. This generally corresponds to either a
truncation, punch hole or a complete invalidation of the address
space (in the latter case 'offset' will always be 0 and 'length'
- will be PAGE_SIZE). Any private data associated with the page
+ will be PAGE_SIZE). Any private data associated with the page
should be updated to reflect this truncation. If offset is 0 and
length is PAGE_SIZE, then the private data should be released,
because the page must be able to be completely discarded. This may
@@ -763,7 +763,7 @@ struct address_space_operations {
releasepage: releasepage is called on PagePrivate pages to indicate
that the page should be freed if possible. ->releasepage
should remove any private data from the page and clear the
- PagePrivate flag. If releasepage() fails for some reason, it must
+ PagePrivate flag. If releasepage() fails for some reason, it must
indicate failure with a 0 return value.
releasepage() is used in two distinct though related cases. The
first is when the VM finds a clean page with no active users and
@@ -783,7 +783,7 @@ struct address_space_operations {
freepage: freepage is called once the page is no longer visible in
the page cache in order to allow the cleanup of any private
- data. Since it may be called by the memory reclaimer, it
+ data. Since it may be called by the memory reclaimer, it
should not assume that the original address_space mapping still
exists, and it should not block.
@@ -805,32 +805,32 @@ struct address_space_operations {
putback_page: Called by the VM when isolated page's migration fails.
- launder_page: Called before freeing a page - it writes back the dirty page. To
+ launder_page: Called before freeing a page - it writes back the dirty page. To
prevent redirtying the page, it is kept locked during the whole
operation.
is_partially_uptodate: Called by the VM when reading a file through the
- pagecache when the underlying blocksize != pagesize. If the required
+ pagecache when the underlying blocksize != pagesize. If the required
block is up to date then the read can complete without needing the IO
to bring the whole page up to date.
is_dirty_writeback: Called by the VM when attempting to reclaim a page.
The VM uses dirty and writeback information to determine if it needs
- to stall to allow flushers a chance to complete some IO. Ordinarily
+ to stall to allow flushers a chance to complete some IO. Ordinarily
it can use PageDirty and PageWriteback but some filesystems have
more complex state (unstable pages in NFS prevent reclaim) or
- do not set those flags due to locking problems. This callback
+ do not set those flags due to locking problems. This callback
allows a filesystem to indicate to the VM if a page should be
treated as dirty or writeback for the purposes of stalling.
error_remove_page: normally set to generic_error_remove_page if truncation
- is ok for this address space. Used for memory failure handling.
+ is ok for this address space. Used for memory failure handling.
Setting this implies you deal with pages going away under you,
unless you have them locked or reference counts increased.
swap_activate: Called when swapon is used on a file to allocate
space if necessary and pin the block lookup information in
- memory. A return value of zero indicates success,
+ memory. A return value of zero indicates success,
in which case this file can be used to back swapspace.
swap_deactivate: Called during swapoff on files where swap_activate
@@ -840,14 +840,14 @@ struct address_space_operations {
The File Object
===============
-A file object represents a file opened by a process. This is also known
+A file object represents a file opened by a process. This is also known
as an "open file description" in POSIX parlance.
struct file_operations
----------------------
-This describes how the VFS can manipulate an open file. As of kernel
+This describes how the VFS can manipulate an open file. As of kernel
4.18, the following members are defined:
struct file_operations {
@@ -912,7 +912,7 @@ otherwise noted.
poll: called by the VFS when a process wants to check if there is
activity on this file and (optionally) go to sleep until there
- is activity. Called by the select(2) and poll(2) system calls
+ is activity. Called by the select(2) and poll(2) system calls
unlocked_ioctl: called by the ioctl(2) system call.
@@ -921,13 +921,13 @@ otherwise noted.
mmap: called by the mmap(2) system call
- open: called by the VFS when an inode should be opened. When the VFS
- opens a file, it creates a new "struct file". It then calls the
- open method for the newly allocated file structure. You might
+ open: called by the VFS when an inode should be opened. When the VFS
+ opens a file, it creates a new "struct file". It then calls the
+ open method for the newly allocated file structure. You might
think that the open method really belongs in
- "struct inode_operations", and you may be right. I think it's
+ "struct inode_operations", and you may be right. I think it's
done the way it is because it makes filesystems simpler to
- implement. The open() method is a good place to initialize the
+ implement. The open() method is a good place to initialize the
"private_data" member in the file structure if you want to point
to a device structure
@@ -935,7 +935,7 @@ otherwise noted.
release: called when the last reference to an open file is closed
- fsync: called by the fsync(2) system call. Also see the section above
+ fsync: called by the fsync(2) system call. Also see the section above
entitled "Handling errors during writeback".
fasync: called by the fcntl(2) system call when asynchronous
@@ -950,13 +950,13 @@ otherwise noted.
flock: called by the flock(2) system call
- splice_write: called by the VFS to splice data from a pipe to a file. This
+ splice_write: called by the VFS to splice data from a pipe to a file. This
method is used by the splice(2) system call
- splice_read: called by the VFS to splice data from file to a pipe. This
+ splice_read: called by the VFS to splice data from file to a pipe. This
method is used by the splice(2) system call
- setlease: called by the VFS to set or release a file lock lease. setlease
+ setlease: called by the VFS to set or release a file lock lease. setlease
implementations should call generic_setlease to record or remove
the lease in the inode after setting it.
@@ -980,12 +980,12 @@ otherwise noted.
fadvise: possibly called by the fadvise64() system call.
Note that the file operations are implemented by the specific
-filesystem in which the inode resides. When opening a device node
+filesystem in which the inode resides. When opening a device node
(character or block special) most filesystems will call special
support routines in the VFS which will locate the required device
-driver information. These support routines replace the filesystem file
+driver information. These support routines replace the filesystem file
operations with those for the device driver, and then proceed to call
-the new open() method for the file. This is how opening a device file
+the new open() method for the file. This is how opening a device file
in the filesystem eventually ends up calling the device driver open()
method.
@@ -998,10 +998,10 @@ struct dentry_operations
------------------------
This describes how a filesystem can overload the standard dentry
-operations. Dentries and the dcache are the domain of the VFS and the
-individual filesystem implementations. Device drivers have no business
-here. These methods may be set to NULL, as they are either optional or
-the VFS uses a default. As of kernel 2.6.22, the following members are
+operations. Dentries and the dcache are the domain of the VFS and the
+individual filesystem implementations. Device drivers have no business
+here. These methods may be set to NULL, as they are either optional or
+the VFS uses a default. As of kernel 2.6.22, the following members are
defined:
struct dentry_operations {
@@ -1020,10 +1020,10 @@ struct dentry_operations {
struct dentry *(*d_real)(struct dentry *, const struct inode *);
};
- d_revalidate: called when the VFS needs to revalidate a dentry. This
+ d_revalidate: called when the VFS needs to revalidate a dentry. This
is called whenever a name look-up finds a dentry in the
- dcache. Most local filesystems leave this as NULL, because all their
- dentries in the dcache are valid. Network filesystems are different
+ dcache. Most local filesystems leave this as NULL, because all their
+ dentries in the dcache are valid. Network filesystems are different
since things can change on the server without the client necessarily
being aware of it.
@@ -1041,11 +1041,11 @@ struct dentry_operations {
d_weak_revalidate: called when the VFS needs to revalidate a "jumped" dentry.
This is called when a path-walk ends at dentry that was not acquired by
- doing a lookup in the parent directory. This includes "/", "." and "..",
+ doing a lookup in the parent directory. This includes "/", "." and "..",
as well as procfs-style symlinks and mountpoint traversal.
In this case, we are less concerned with whether the dentry is still
- fully correct, but rather that the inode is still valid. As with
+ fully correct, but rather that the inode is still valid. As with
d_revalidate, most local filesystems will set this to NULL since their
dcache entries are always valid.
@@ -1053,17 +1053,17 @@ struct dentry_operations {
d_weak_revalidate is only called after leaving rcu-walk mode.
- d_hash: called when the VFS adds a dentry to the hash table. The first
+ d_hash: called when the VFS adds a dentry to the hash table. The first
dentry passed to d_hash is the parent directory that the name is
to be hashed into.
Same locking and synchronisation rules as d_compare regarding
what is safe to dereference etc.
- d_compare: called to compare a dentry name with a given name. The first
+ d_compare: called to compare a dentry name with a given name. The first
dentry is the parent of the dentry to be compared, the second is
- the child dentry. len and name string are properties of the dentry
- to be compared. qstr is the name to compare it with.
+ the child dentry. len and name string are properties of the dentry
+ to be compared. qstr is the name to compare it with.
Must be constant and idempotent, and should not take locks if
possible, and should not or store into the dentry.
@@ -1078,9 +1078,9 @@ struct dentry_operations {
"rcu-walk", ie. without any locks or references on things.
d_delete: called when the last reference to a dentry is dropped and the
- dcache is deciding whether or not to cache it. Return 1 to delete
- immediately, or 0 to cache the dentry. Default is NULL which means to
- always cache a reachable dentry. d_delete must be constant and
+ dcache is deciding whether or not to cache it. Return 1 to delete
+ immediately, or 0 to cache the dentry. Default is NULL which means to
+ always cache a reachable dentry. d_delete must be constant and
idempotent.
d_init: called when a dentry is allocated
@@ -1088,19 +1088,19 @@ struct dentry_operations {
d_release: called when a dentry is really deallocated
d_iput: called when a dentry loses its inode (just prior to its
- being deallocated). The default when this is NULL is that the
- VFS calls iput(). If you define this method, you must call
+ being deallocated). The default when this is NULL is that the
+ VFS calls iput(). If you define this method, you must call
iput() yourself
d_dname: called when the pathname of a dentry should be generated.
Useful for some pseudo filesystems (sockfs, pipefs, ...) to delay
- pathname generation. (Instead of doing it when dentry is created,
- it's done only when the path is needed.). Real filesystems probably
+ pathname generation. (Instead of doing it when dentry is created,
+ it's done only when the path is needed.). Real filesystems probably
dont want to use it, because their dentries are present in global
- dcache hash, so their hash should be an invariant. As no lock is
+ dcache hash, so their hash should be an invariant. As no lock is
held, d_dname() should not try to modify the dentry itself, unless
- appropriate SMP safety is used. CAUTION : d_path() logic is quite
- tricky. The correct way to return for example "Hello" is to put it
+ appropriate SMP safety is used. CAUTION : d_path() logic is quite
+ tricky. The correct way to return for example "Hello" is to put it
at the end of the buffer, and returns a pointer to the first char.
dynamic_dname() helper function is provided to take care of this.
@@ -1162,7 +1162,7 @@ struct dentry_operations {
With NULL inode the topmost real underlying dentry is returned.
Each dentry has a pointer to its parent dentry, as well as a hash list
-of child dentries. Child dentries are basically like files in a
+of child dentries. Child dentries are basically like files in a
directory.
@@ -1175,36 +1175,36 @@ manipulate dentries:
dget: open a new handle for an existing dentry (this just increments
the usage count)
- dput: close a handle for a dentry (decrements the usage count). If
+ dput: close a handle for a dentry (decrements the usage count). If
the usage count drops to 0, and the dentry is still in its
parent's hash, the "d_delete" method is called to check whether
- it should be cached. If it should not be cached, or if the dentry
- is not hashed, it is deleted. Otherwise cached dentries are put
+ it should be cached. If it should not be cached, or if the dentry
+ is not hashed, it is deleted. Otherwise cached dentries are put
into an LRU list to be reclaimed on memory shortage.
- d_drop: this unhashes a dentry from its parents hash list. A
+ d_drop: this unhashes a dentry from its parents hash list. A
subsequent call to dput() will deallocate the dentry if its
usage count drops to 0
- d_delete: delete a dentry. If there are no other open references to
+ d_delete: delete a dentry. If there are no other open references to
the dentry then the dentry is turned into a negative dentry
- (the d_iput() method is called). If there are other
+ (the d_iput() method is called). If there are other
references, then d_drop() is called instead
d_add: add a dentry to its parents hash list and then calls
d_instantiate()
d_instantiate: add a dentry to the alias hash list for the inode and
- updates the "d_inode" member. The "i_count" member in the
- inode structure should be set/incremented. If the inode
+ updates the "d_inode" member. The "i_count" member in the
+ inode structure should be set/incremented. If the inode
pointer is NULL, the dentry is called a "negative
- dentry". This function is commonly called when an inode is
+ dentry". This function is commonly called when an inode is
created for an existing negative dentry
d_lookup: look up a dentry given its parent and path name component
It looks up the child of that given name from the dcache
- hash table. If it is found, the reference count is incremented
- and the dentry is returned. The caller must use dput()
+ hash table. If it is found, the reference count is incremented
+ and the dentry is returned. The caller must use dput()
to free the dentry when it finishes using it.
Mount Options
--
2.21.0
^ permalink raw reply related
* [PATCH v4 6/9] docs: filesystems: vfs: Use SPDX identifier
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
Currently the licence is indicated via a custom string. We have SPDX
license identifiers now for this task.
Use SPDX license identifier matching current license string.
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 790feccca5f4..5c8358c73e30 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -1,3 +1,5 @@
+.. SPDX-License-Identifier: GPL-2.0
+
=========================================
Overview of the Linux Virtual File System
=========================================
@@ -9,8 +11,6 @@ Overview of the Linux Virtual File System
Copyright (C) 1999 Richard Gooch
Copyright (C) 2005 Pekka Enberg
- This file is released under the GPLv2.
-
Introduction
============
--
2.21.0
^ permalink raw reply related
* [PATCH v4 7/9] docs: filesystems: vfs: Fix pre-amble indentation
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
Currently file pre-amble contains custom indentation. RST is not going
to like this, lets left-align the text. Put the copyright notices in a
list in preparation for converting document to RST.
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 5c8358c73e30..43b18bafbc20 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -4,12 +4,12 @@
Overview of the Linux Virtual File System
=========================================
- Original author: Richard Gooch <rgooch@atnf.csiro.au>
+Original author: Richard Gooch <rgooch@atnf.csiro.au>
- Last updated on June 24, 2007.
+Last updated on June 24, 2007.
- Copyright (C) 1999 Richard Gooch
- Copyright (C) 2005 Pekka Enberg
+- Copyright (C) 1999 Richard Gooch
+- Copyright (C) 2005 Pekka Enberg
Introduction
--
2.21.0
^ permalink raw reply related
* [PATCH v4 9/9] docs: filesystems: vfs: Convert vfs.txt to RST
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
vfs.txt is currently stale. If we convert it to RST this is a good
first step in the process of getting the VFS documentation up to date.
This patch does the following (all as a single patch so as not to
introduce any new SPHINX build warnings)
- Use '.. code-block:: c' for C code blocks and indent the code blocks.
- Use double backticks for struct member descriptions.
- Fix a couple of build warnings by guarding pointers (*) with double
backticks .e.g ``*ptr``.
- Add vfs to Documentation/filesystems/index.rst
The member descriptions paragraph indentation was not touched. It is
not pretty but these do not cause build warnings. These descriptions
all need updating anyways so leave it as it is for now.
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/index.rst | 1 +
.../filesystems/{vfs.txt => vfs.rst} | 578 +++++++++---------
2 files changed, 298 insertions(+), 281 deletions(-)
rename Documentation/filesystems/{vfs.txt => vfs.rst} (70%)
diff --git a/Documentation/filesystems/index.rst b/Documentation/filesystems/index.rst
index 1131c34d77f6..35644840a690 100644
--- a/Documentation/filesystems/index.rst
+++ b/Documentation/filesystems/index.rst
@@ -16,6 +16,7 @@ algorithms work.
.. toctree::
:maxdepth: 2
+ vfs
path-lookup.rst
api-summary
splice
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.rst
similarity index 70%
rename from Documentation/filesystems/vfs.txt
rename to Documentation/filesystems/vfs.rst
index 489bbdc6a40f..3acb74bdddf6 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.rst
@@ -87,10 +87,12 @@ Registering and Mounting a Filesystem
To register and unregister a filesystem, use the following API
functions:
- #include <linux/fs.h>
+.. code-block:: c
- extern int register_filesystem(struct file_system_type *);
- extern int unregister_filesystem(struct file_system_type *);
+ #include <linux/fs.h>
+
+ extern int register_filesystem(struct file_system_type *);
+ extern int unregister_filesystem(struct file_system_type *);
The passed struct file_system_type describes your filesystem. When a
request is made to mount a filesystem onto a directory in your
@@ -110,47 +112,49 @@ struct file_system_type
This describes the filesystem. As of kernel 2.6.39, the following
members are defined:
-struct file_system_type {
- const char *name;
- int fs_flags;
- struct dentry *(*mount) (struct file_system_type *, int,
- const char *, void *);
- void (*kill_sb) (struct super_block *);
- struct module *owner;
- struct file_system_type * next;
- struct list_head fs_supers;
- struct lock_class_key s_lock_key;
- struct lock_class_key s_umount_key;
-};
-
- name: the name of the filesystem type, such as "ext2", "iso9660",
+.. code-block:: c
+
+ struct file_system_operations {
+ const char *name;
+ int fs_flags;
+ struct dentry *(*mount) (struct file_system_type *, int,
+ const char *, void *);
+ void (*kill_sb) (struct super_block *);
+ struct module *owner;
+ struct file_system_type * next;
+ struct list_head fs_supers;
+ struct lock_class_key s_lock_key;
+ struct lock_class_key s_umount_key;
+ };
+
+``name``: the name of the filesystem type, such as "ext2", "iso9660",
"msdos" and so on
- fs_flags: various flags (i.e. FS_REQUIRES_DEV, FS_NO_DCACHE, etc.)
+``fs_flags``: various flags (i.e. FS_REQUIRES_DEV, FS_NO_DCACHE, etc.)
- mount: the method to call when a new instance of this
- filesystem should be mounted
+``mount``: the method to call when a new instance of this filesystem should
+be mounted
- kill_sb: the method to call when an instance of this filesystem
+``kill_sb``: the method to call when an instance of this filesystem
should be shut down
- owner: for internal VFS use: you should initialize this to THIS_MODULE in
+``owner``: for internal VFS use: you should initialize this to THIS_MODULE in
most cases.
- next: for internal VFS use: you should initialize this to NULL
+``next``: for internal VFS use: you should initialize this to NULL
s_lock_key, s_umount_key: lockdep-specific
The mount() method has the following arguments:
- struct file_system_type *fs_type: describes the filesystem, partly initialized
+``struct file_system_type *fs_type``: describes the filesystem, partly initialized
by the specific filesystem code
- int flags: mount flags
+``int flags``: mount flags
- const char *dev_name: the device name we are mounting.
+``const char *dev_name``: the device name we are mounting.
- void *data: arbitrary mount options, usually comes as an ASCII
+``void *data``: arbitrary mount options, usually comes as an ASCII
string (see "Mount Options" section)
The mount() method must return the root dentry of the tree requested by
@@ -176,22 +180,22 @@ implementation.
Usually, a filesystem uses one of the generic mount() implementations
and provides a fill_super() callback instead. The generic variants are:
- mount_bdev: mount a filesystem residing on a block device
+``mount_bdev``: mount a filesystem residing on a block device
- mount_nodev: mount a filesystem that is not backed by a device
+``mount_nodev``: mount a filesystem that is not backed by a device
- mount_single: mount a filesystem which shares the instance between
+``mount_single``: mount a filesystem which shares the instance between
all mounts
A fill_super() callback implementation has the following arguments:
- struct super_block *sb: the superblock structure. The callback
+``struct super_block *sb``: the superblock structure. The callback
must initialize this properly.
- void *data: arbitrary mount options, usually comes as an ASCII
+``void *data``: arbitrary mount options, usually comes as an ASCII
string (see "Mount Options" section)
- int silent: whether or not to be silent on error
+``int silent``: whether or not to be silent on error
The Superblock Object
@@ -206,54 +210,56 @@ struct super_operations
This describes how the VFS can manipulate the superblock of your
filesystem. As of kernel 2.6.22, the following members are defined:
-struct super_operations {
- struct inode *(*alloc_inode)(struct super_block *sb);
- void (*destroy_inode)(struct inode *);
-
- void (*dirty_inode) (struct inode *, int flags);
- int (*write_inode) (struct inode *, int);
- void (*drop_inode) (struct inode *);
- void (*delete_inode) (struct inode *);
- void (*put_super) (struct super_block *);
- int (*sync_fs)(struct super_block *sb, int wait);
- int (*freeze_fs) (struct super_block *);
- int (*unfreeze_fs) (struct super_block *);
- int (*statfs) (struct dentry *, struct kstatfs *);
- int (*remount_fs) (struct super_block *, int *, char *);
- void (*clear_inode) (struct inode *);
- void (*umount_begin) (struct super_block *);
-
- int (*show_options)(struct seq_file *, struct dentry *);
-
- ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
- ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
- int (*nr_cached_objects)(struct super_block *);
- void (*free_cached_objects)(struct super_block *, int);
-};
+.. code-block:: c
+
+ struct super_operations {
+ struct inode *(*alloc_inode)(struct super_block *sb);
+ void (*destroy_inode)(struct inode *);
+
+ void (*dirty_inode) (struct inode *, int flags);
+ int (*write_inode) (struct inode *, int);
+ void (*drop_inode) (struct inode *);
+ void (*delete_inode) (struct inode *);
+ void (*put_super) (struct super_block *);
+ int (*sync_fs)(struct super_block *sb, int wait);
+ int (*freeze_fs) (struct super_block *);
+ int (*unfreeze_fs) (struct super_block *);
+ int (*statfs) (struct dentry *, struct kstatfs *);
+ int (*remount_fs) (struct super_block *, int *, char *);
+ void (*clear_inode) (struct inode *);
+ void (*umount_begin) (struct super_block *);
+
+ int (*show_options)(struct seq_file *, struct dentry *);
+
+ ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
+ ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
+ int (*nr_cached_objects)(struct super_block *);
+ void (*free_cached_objects)(struct super_block *, int);
+ };
All methods are called without any locks being held, unless otherwise
noted. This means that most methods can block safely. All methods are
only called from a process context (i.e. not from an interrupt handler
or bottom half).
- alloc_inode: this method is called by alloc_inode() to allocate memory
+``alloc_inode``: this method is called by alloc_inode() to allocate memory
for struct inode and initialize it. If this function is not
defined, a simple 'struct inode' is allocated. Normally
alloc_inode will be used to allocate a larger structure which
contains a 'struct inode' embedded within it.
- destroy_inode: this method is called by destroy_inode() to release
+``destroy_inode``: this method is called by destroy_inode() to release
resources allocated for struct inode. It is only required if
->alloc_inode was defined and simply undoes anything done by
->alloc_inode.
- dirty_inode: this method is called by the VFS to mark an inode dirty.
+``dirty_inode``: this method is called by the VFS to mark an inode dirty.
- write_inode: this method is called when the VFS needs to write an
+``write_inode``: this method is called when the VFS needs to write an
inode to disc. The second parameter indicates whether the write
should be synchronous or not, not all filesystems check this flag.
- drop_inode: called when the last access to the inode is dropped,
+``drop_inode``: called when the last access to the inode is dropped,
with the inode->i_lock spinlock held.
This method should be either NULL (normal UNIX filesystem
@@ -266,43 +272,43 @@ or bottom half).
but does not have the races that the "force_delete()" approach
had.
- delete_inode: called when the VFS wants to delete an inode
+``delete_inode``: called when the VFS wants to delete an inode
- put_super: called when the VFS wishes to free the superblock
+``put_super``: called when the VFS wishes to free the superblock
(i.e. unmount). This is called with the superblock lock held
- sync_fs: called when VFS is writing out all dirty data associated with
+``sync_fs``: called when VFS is writing out all dirty data associated with
a superblock. The second parameter indicates whether the method
should wait until the write out has been completed. Optional.
- freeze_fs: called when VFS is locking a filesystem and
+``freeze_fs``: called when VFS is locking a filesystem and
forcing it into a consistent state. This method is currently
used by the Logical Volume Manager (LVM).
- unfreeze_fs: called when VFS is unlocking a filesystem and making it writable
+``unfreeze_fs``: called when VFS is unlocking a filesystem and making it writable
again.
- statfs: called when the VFS needs to get filesystem statistics.
+``statfs``: called when the VFS needs to get filesystem statistics.
- remount_fs: called when the filesystem is remounted. This is called
+``remount_fs``: called when the filesystem is remounted. This is called
with the kernel lock held
- clear_inode: called then the VFS clears the inode. Optional
+``clear_inode``: called then the VFS clears the inode. Optional
- umount_begin: called when the VFS is unmounting a filesystem.
+``umount_begin``: called when the VFS is unmounting a filesystem.
- show_options: called by the VFS to show mount options for
+``show_options``: called by the VFS to show mount options for
/proc/<pid>/mounts. (see "Mount Options" section)
- quota_read: called by the VFS to read from filesystem quota file.
+``quota_read``: called by the VFS to read from filesystem quota file.
- quota_write: called by the VFS to write to filesystem quota file.
+``quota_write``: called by the VFS to write to filesystem quota file.
- nr_cached_objects: called by the sb cache shrinking function for the
+``nr_cached_objects``: called by the sb cache shrinking function for the
filesystem to return the number of freeable cached objects it contains.
Optional.
- free_cache_objects: called by the sb cache shrinking function for the
+``free_cache_objects``: called by the sb cache shrinking function for the
filesystem to scan the number of objects indicated to try to free them.
Optional, but any filesystem implementing this method needs to also
implement ->nr_cached_objects for it to be called correctly.
@@ -330,27 +336,27 @@ On filesystems that support extended attributes (xattrs), the s_xattr
superblock field points to a NULL-terminated array of xattr handlers.
Extended attributes are name:value pairs.
- name: Indicates that the handler matches attributes with the specified name
+``name``: Indicates that the handler matches attributes with the specified name
(such as "system.posix_acl_access"); the prefix field must be NULL.
- prefix: Indicates that the handler matches all attributes with the specified
+``prefix``: Indicates that the handler matches all attributes with the specified
name prefix (such as "user."); the name field must be NULL.
- list: Determine if attributes matching this xattr handler should be listed
+``list``: Determine if attributes matching this xattr handler should be listed
for a particular dentry. Used by some listxattr implementations like
generic_listxattr.
- get: Called by the VFS to get the value of a particular extended attribute.
+``get``: Called by the VFS to get the value of a particular extended attribute.
This method is called by the getxattr(2) system call.
- set: Called by the VFS to set the value of a particular extended attribute.
+``set``: Called by the VFS to set the value of a particular extended attribute.
When the new value is NULL, called to remove a particular extended
attribute. This method is called by the the setxattr(2) and
removexattr(2) system calls.
When none of the xattr handlers of a filesystem match the specified
attribute name or when a filesystem doesn't support extended attributes,
-the various *xattr(2) system calls return -EOPNOTSUPP.
+the various ``*xattr(2)`` system calls return -EOPNOTSUPP.
The Inode Object
@@ -365,41 +371,43 @@ struct inode_operations
This describes how the VFS can manipulate an inode in your filesystem.
As of kernel 2.6.22, the following members are defined:
-struct inode_operations {
- int (*create) (struct inode *,struct dentry *, umode_t, bool);
- struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
- int (*link) (struct dentry *,struct inode *,struct dentry *);
- int (*unlink) (struct inode *,struct dentry *);
- int (*symlink) (struct inode *,struct dentry *,const char *);
- int (*mkdir) (struct inode *,struct dentry *,umode_t);
- int (*rmdir) (struct inode *,struct dentry *);
- int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
- int (*rename) (struct inode *, struct dentry *,
- struct inode *, struct dentry *, unsigned int);
- int (*readlink) (struct dentry *, char __user *,int);
- const char *(*get_link) (struct dentry *, struct inode *,
- struct delayed_call *);
- int (*permission) (struct inode *, int);
- int (*get_acl)(struct inode *, int);
- int (*setattr) (struct dentry *, struct iattr *);
- int (*getattr) (const struct path *, struct kstat *, u32, unsigned int);
- ssize_t (*listxattr) (struct dentry *, char *, size_t);
- void (*update_time)(struct inode *, struct timespec *, int);
- int (*atomic_open)(struct inode *, struct dentry *, struct file *,
- unsigned open_flag, umode_t create_mode);
- int (*tmpfile) (struct inode *, struct dentry *, umode_t);
-};
+.. code-block:: c
+
+ struct inode_operations {
+ int (*create) (struct inode *,struct dentry *, umode_t, bool);
+ struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
+ int (*link) (struct dentry *,struct inode *,struct dentry *);
+ int (*unlink) (struct inode *,struct dentry *);
+ int (*symlink) (struct inode *,struct dentry *,const char *);
+ int (*mkdir) (struct inode *,struct dentry *,umode_t);
+ int (*rmdir) (struct inode *,struct dentry *);
+ int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
+ int (*rename) (struct inode *, struct dentry *,
+ struct inode *, struct dentry *, unsigned int);
+ int (*readlink) (struct dentry *, char __user *,int);
+ const char *(*get_link) (struct dentry *, struct inode *,
+ struct delayed_call *);
+ int (*permission) (struct inode *, int);
+ int (*get_acl)(struct inode *, int);
+ int (*setattr) (struct dentry *, struct iattr *);
+ int (*getattr) (const struct path *, struct kstat *, u32, unsigned int);
+ ssize_t (*listxattr) (struct dentry *, char *, size_t);
+ void (*update_time)(struct inode *, struct timespec *, int);
+ int (*atomic_open)(struct inode *, struct dentry *, struct file *,
+ unsigned open_flag, umode_t create_mode);
+ int (*tmpfile) (struct inode *, struct dentry *, umode_t);
+ };
Again, all methods are called without any locks being held, unless
otherwise noted.
- create: called by the open(2) and creat(2) system calls. Only
+``create``: called by the open(2) and creat(2) system calls. Only
required if you want to support regular files. The dentry you
get should not have an inode (i.e. it should be a negative
dentry). Here you will probably call d_instantiate() with the
dentry and the newly created inode
- lookup: called when the VFS needs to look up an inode in a parent
+``lookup``: called when the VFS needs to look up an inode in a parent
directory. The name to look for is found in the dentry. This
method must call d_add() to insert the found inode into the
dentry. The "i_count" field in the inode structure should be
@@ -413,31 +421,31 @@ otherwise noted.
to a struct "dentry_operations".
This method is called with the directory inode semaphore held
- link: called by the link(2) system call. Only required if you want
+``link``: called by the link(2) system call. Only required if you want
to support hard links. You will probably need to call
d_instantiate() just as you would in the create() method
- unlink: called by the unlink(2) system call. Only required if you
+``unlink``: called by the unlink(2) system call. Only required if you
want to support deleting inodes
- symlink: called by the symlink(2) system call. Only required if you
+``symlink``: called by the symlink(2) system call. Only required if you
want to support symlinks. You will probably need to call
d_instantiate() just as you would in the create() method
- mkdir: called by the mkdir(2) system call. Only required if you want
+``mkdir``: called by the mkdir(2) system call. Only required if you want
to support creating subdirectories. You will probably need to
call d_instantiate() just as you would in the create() method
- rmdir: called by the rmdir(2) system call. Only required if you want
+``rmdir``: called by the rmdir(2) system call. Only required if you want
to support deleting subdirectories
- mknod: called by the mknod(2) system call to create a device (char,
+``mknod``: called by the mknod(2) system call to create a device (char,
block) inode or a named pipe (FIFO) or socket. Only required
if you want to support creating these types of inodes. You
will probably need to call d_instantiate() just as you would
in the create() method
- rename: called by the rename(2) system call to rename the object to
+``rename``: called by the rename(2) system call to rename the object to
have the parent and name given by the second inode and dentry.
The filesystem must return -EINVAL for any unsupported or
@@ -451,7 +459,7 @@ otherwise noted.
exist; this is checked by the VFS. Unlike plain rename,
source and target may be of different type.
- get_link: called by the VFS to follow a symbolic link to the
+``get_link``: called by the VFS to follow a symbolic link to the
inode it points to. Only required if you want to support
symbolic links. This method returns the symlink body
to traverse (and possibly resets the current position with
@@ -465,13 +473,13 @@ otherwise noted.
argument. If request can't be handled without leaving RCU mode,
have it return ERR_PTR(-ECHILD).
- readlink: this is now just an override for use by readlink(2) for the
+``readlink``: this is now just an override for use by readlink(2) for the
cases when ->get_link uses nd_jump_link() or object is not in
fact a symlink. Normally filesystems should only implement
->get_link for symlinks and readlink(2) will automatically use
that.
- permission: called by the VFS to check for access rights on a POSIX-like
+``permission``: called by the VFS to check for access rights on a POSIX-like
filesystem.
May be called in rcu-walk mode (mask & MAY_NOT_BLOCK). If in rcu-walk
@@ -481,20 +489,20 @@ otherwise noted.
If a situation is encountered that rcu-walk cannot handle, return
-ECHILD and it will be called again in ref-walk mode.
- setattr: called by the VFS to set attributes for a file. This method
+``setattr``: called by the VFS to set attributes for a file. This method
is called by chmod(2) and related system calls.
- getattr: called by the VFS to get attributes of a file. This method
+``getattr``: called by the VFS to get attributes of a file. This method
is called by stat(2) and related system calls.
- listxattr: called by the VFS to list all extended attributes for a
+``listxattr``: called by the VFS to list all extended attributes for a
given file. This method is called by the listxattr(2) system call.
- update_time: called by the VFS to update a specific time or the i_version of
+``update_time``: called by the VFS to update a specific time or the i_version of
an inode. If this is not defined the VFS will update the inode itself
and call mark_inode_dirty_sync.
- atomic_open: called on the last component of an open. Using this optional
+``atomic_open``: called on the last component of an open. Using this optional
method the filesystem can look up, possibly create and open the file in
one atomic operation. If it wants to leave actual opening to the
caller (e.g. if the file turned out to be a symlink, device, or just
@@ -506,7 +514,7 @@ otherwise noted.
the method must only succeed if the file didn't exist and hence FMODE_CREATED
shall always be set on success.
- tmpfile: called in the end of O_TMPFILE open(). Optional, equivalent to
+``tmpfile``: called in the end of O_TMPFILE open(). Optional, equivalent to
atomically creating, opening and unlinking a file in given directory.
@@ -624,41 +632,43 @@ struct address_space_operations
This describes how the VFS can manipulate mapping of a file to page
cache in your filesystem. The following members are defined:
-struct address_space_operations {
- int (*writepage)(struct page *page, struct writeback_control *wbc);
- int (*readpage)(struct file *, struct page *);
- int (*writepages)(struct address_space *, struct writeback_control *);
- int (*set_page_dirty)(struct page *page);
- int (*readpages)(struct file *filp, struct address_space *mapping,
- struct list_head *pages, unsigned nr_pages);
- int (*write_begin)(struct file *, struct address_space *mapping,
- loff_t pos, unsigned len, unsigned flags,
+.. code-block:: c
+
+ struct address_space_operations {
+ int (*writepage)(struct page *page, struct writeback_control *wbc);
+ int (*readpage)(struct file *, struct page *);
+ int (*writepages)(struct address_space *, struct writeback_control *);
+ int (*set_page_dirty)(struct page *page);
+ int (*readpages)(struct file *filp, struct address_space *mapping,
+ struct list_head *pages, unsigned nr_pages);
+ int (*write_begin)(struct file *, struct address_space *mapping,
+ loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
- int (*write_end)(struct file *, struct address_space *mapping,
- loff_t pos, unsigned len, unsigned copied,
- struct page *page, void *fsdata);
- sector_t (*bmap)(struct address_space *, sector_t);
- void (*invalidatepage) (struct page *, unsigned int, unsigned int);
- int (*releasepage) (struct page *, int);
- void (*freepage)(struct page *);
- ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
- /* isolate a page for migration */
- bool (*isolate_page) (struct page *, isolate_mode_t);
- /* migrate the contents of a page to the specified target */
- int (*migratepage) (struct page *, struct page *);
- /* put migration-failed page back to right list */
- void (*putback_page) (struct page *);
- int (*launder_page) (struct page *);
-
- int (*is_partially_uptodate) (struct page *, unsigned long,
- unsigned long);
- void (*is_dirty_writeback) (struct page *, bool *, bool *);
- int (*error_remove_page) (struct mapping *mapping, struct page *page);
- int (*swap_activate)(struct file *);
- int (*swap_deactivate)(struct file *);
-};
-
- writepage: called by the VM to write a dirty page to backing store.
+ int (*write_end)(struct file *, struct address_space *mapping,
+ loff_t pos, unsigned len, unsigned copied,
+ struct page *page, void *fsdata);
+ sector_t (*bmap)(struct address_space *, sector_t);
+ void (*invalidatepage) (struct page *, unsigned int, unsigned int);
+ int (*releasepage) (struct page *, int);
+ void (*freepage)(struct page *);
+ ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
+ /* isolate a page for migration */
+ bool (*isolate_page) (struct page *, isolate_mode_t);
+ /* migrate the contents of a page to the specified target */
+ int (*migratepage) (struct page *, struct page *);
+ /* put migration-failed page back to right list */
+ void (*putback_page) (struct page *);
+ int (*launder_page) (struct page *);
+
+ int (*is_partially_uptodate) (struct page *, unsigned long,
+ unsigned long);
+ void (*is_dirty_writeback) (struct page *, bool *, bool *);
+ int (*error_remove_page) (struct mapping *mapping, struct page *page);
+ int (*swap_activate)(struct file *);
+ int (*swap_deactivate)(struct file *);
+ };
+
+``writepage``: called by the VM to write a dirty page to backing store.
This may happen for data integrity reasons (i.e. 'sync'), or
to free up memory (flush). The difference can be seen in
wbc->sync_mode.
@@ -676,7 +686,7 @@ struct address_space_operations {
See the file "Locking" for more details.
- readpage: called by the VM to read a page from backing store.
+``readpage``: called by the VM to read a page from backing store.
The page will be Locked when readpage is called, and should be
unlocked and marked uptodate once the read completes.
If ->readpage discovers that it needs to unlock the page for
@@ -684,7 +694,7 @@ struct address_space_operations {
In this case, the page will be relocated, relocked and if
that all succeeds, ->readpage will be called again.
- writepages: called by the VM to write out pages associated with the
+``writepages``: called by the VM to write out pages associated with the
address_space object. If wbc->sync_mode is WBC_SYNC_ALL, then
the writeback_control will specify a range of pages that must be
written out. If it is WBC_SYNC_NONE, then a nr_to_write is given
@@ -693,7 +703,7 @@ struct address_space_operations {
instead. This will choose pages from the address space that are
tagged as DIRTY and will pass them to ->writepage.
- set_page_dirty: called by the VM to set a page dirty.
+``set_page_dirty``: called by the VM to set a page dirty.
This is particularly needed if an address space attaches
private data to a page, and that data needs to be updated when
a page is dirtied. This is called, for example, when a memory
@@ -701,14 +711,14 @@ struct address_space_operations {
If defined, it should set the PageDirty flag, and the
PAGECACHE_TAG_DIRTY tag in the radix tree.
- readpages: called by the VM to read pages associated with the address_space
+``readpages``: called by the VM to read pages associated with the address_space
object. This is essentially just a vector version of
readpage. Instead of just one page, several pages are
requested.
readpages is only used for read-ahead, so read errors are
ignored. If anything goes wrong, feel free to give up.
- write_begin:
+``write_begin``:
Called by the generic buffered write code to ask the filesystem to
prepare to write len bytes at the given offset in the file. The
address_space should check that the write will be able to complete,
@@ -718,7 +728,7 @@ struct address_space_operations {
read already) so that the updated blocks can be written out properly.
The filesystem must return the locked pagecache page for the specified
- offset, in *pagep, for the caller to write into.
+ offset, in ``*pagep``, for the caller to write into.
It must be able to cope with short writes (where the length passed to
write_begin is greater than the number of bytes copied into the page).
@@ -732,7 +742,7 @@ struct address_space_operations {
Returns 0 on success; < 0 on failure (which is the error code), in
which case write_end is not called.
- write_end: After a successful write_begin, and data copy, write_end must
+``write_end``: After a successful write_begin, and data copy, write_end must
be called. len is the original len passed to write_begin, and copied
is the amount that was able to be copied.
@@ -742,7 +752,7 @@ struct address_space_operations {
Returns < 0 on failure, otherwise the number of bytes (<= 'copied')
that were able to be copied into pagecache.
- bmap: called by the VFS to map a logical block offset within object to
+``bmap``: called by the VFS to map a logical block offset within object to
physical block number. This method is used by the FIBMAP
ioctl and for working with swap-files. To be able to swap to
a file, the file must have a stable mapping to a block
@@ -750,7 +760,7 @@ struct address_space_operations {
but instead uses bmap to find out where the blocks in the file
are and uses those addresses directly.
- invalidatepage: If a page has PagePrivate set, then invalidatepage
+``invalidatepage``: If a page has PagePrivate set, then invalidatepage
will be called when part or all of the page is to be removed
from the address space. This generally corresponds to either a
truncation, punch hole or a complete invalidation of the address
@@ -762,7 +772,7 @@ struct address_space_operations {
be done by calling the ->releasepage function, but in this case the
release MUST succeed.
- releasepage: releasepage is called on PagePrivate pages to indicate
+``releasepage``: releasepage is called on PagePrivate pages to indicate
that the page should be freed if possible. ->releasepage
should remove any private data from the page and clear the
PagePrivate flag. If releasepage() fails for some reason, it must
@@ -783,40 +793,40 @@ struct address_space_operations {
need to ensure this. Possibly it can clear the PageUptodate
bit if it cannot free private data yet.
- freepage: freepage is called once the page is no longer visible in
+``freepage``: freepage is called once the page is no longer visible in
the page cache in order to allow the cleanup of any private
data. Since it may be called by the memory reclaimer, it
should not assume that the original address_space mapping still
exists, and it should not block.
- direct_IO: called by the generic read/write routines to perform
+``direct_IO``: called by the generic read/write routines to perform
direct_IO - that is IO requests which bypass the page cache
and transfer data directly between the storage and the
application's address space.
- isolate_page: Called by the VM when isolating a movable non-lru page.
+``isolate_page``: Called by the VM when isolating a movable non-lru page.
If page is successfully isolated, VM marks the page as PG_isolated
via __SetPageIsolated.
- migrate_page: This is used to compact the physical memory usage.
+``migrate_page``: This is used to compact the physical memory usage.
If the VM wants to relocate a page (maybe off a memory card
that is signalling imminent failure) it will pass a new page
and an old page to this function. migrate_page should
transfer any private data across and update any references
that it has to the page.
- putback_page: Called by the VM when isolated page's migration fails.
+``putback_page``: Called by the VM when isolated page's migration fails.
- launder_page: Called before freeing a page - it writes back the dirty page. To
+``launder_page``: Called before freeing a page - it writes back the dirty page. To
prevent redirtying the page, it is kept locked during the whole
operation.
- is_partially_uptodate: Called by the VM when reading a file through the
+``is_partially_uptodate``: Called by the VM when reading a file through the
pagecache when the underlying blocksize != pagesize. If the required
block is up to date then the read can complete without needing the IO
to bring the whole page up to date.
- is_dirty_writeback: Called by the VM when attempting to reclaim a page.
+``is_dirty_writeback``: Called by the VM when attempting to reclaim a page.
The VM uses dirty and writeback information to determine if it needs
to stall to allow flushers a chance to complete some IO. Ordinarily
it can use PageDirty and PageWriteback but some filesystems have
@@ -825,17 +835,17 @@ struct address_space_operations {
allows a filesystem to indicate to the VM if a page should be
treated as dirty or writeback for the purposes of stalling.
- error_remove_page: normally set to generic_error_remove_page if truncation
+``error_remove_page``: normally set to generic_error_remove_page if truncation
is ok for this address space. Used for memory failure handling.
Setting this implies you deal with pages going away under you,
unless you have them locked or reference counts increased.
- swap_activate: Called when swapon is used on a file to allocate
+``swap_activate``: Called when swapon is used on a file to allocate
space if necessary and pin the block lookup information in
memory. A return value of zero indicates success,
in which case this file can be used to back swapspace.
- swap_deactivate: Called during swapoff on files where swap_activate
+``swap_deactivate``: Called during swapoff on files where swap_activate
was successful.
@@ -852,78 +862,80 @@ struct file_operations
This describes how the VFS can manipulate an open file. As of kernel
4.18, the following members are defined:
-struct file_operations {
- struct module *owner;
- loff_t (*llseek) (struct file *, loff_t, int);
- ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
- ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
- ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
- ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
- int (*iopoll)(struct kiocb *kiocb, bool spin);
- int (*iterate) (struct file *, struct dir_context *);
- int (*iterate_shared) (struct file *, struct dir_context *);
- __poll_t (*poll) (struct file *, struct poll_table_struct *);
- long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
- long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
- int (*mmap) (struct file *, struct vm_area_struct *);
- int (*open) (struct inode *, struct file *);
- int (*flush) (struct file *, fl_owner_t id);
- int (*release) (struct inode *, struct file *);
- int (*fsync) (struct file *, loff_t, loff_t, int datasync);
- int (*fasync) (int, struct file *, int);
- int (*lock) (struct file *, int, struct file_lock *);
- ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
- unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
- int (*check_flags)(int);
- int (*flock) (struct file *, int, struct file_lock *);
- ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
- ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
- int (*setlease)(struct file *, long, struct file_lock **, void **);
- long (*fallocate)(struct file *file, int mode, loff_t offset,
- loff_t len);
- void (*show_fdinfo)(struct seq_file *m, struct file *f);
-#ifndef CONFIG_MMU
- unsigned (*mmap_capabilities)(struct file *);
-#endif
- ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int);
- loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
- struct file *file_out, loff_t pos_out,
- loff_t len, unsigned int remap_flags);
- int (*fadvise)(struct file *, loff_t, loff_t, int);
-};
+.. code-block:: c
+
+ struct file_operations {
+ struct module *owner;
+ loff_t (*llseek) (struct file *, loff_t, int);
+ ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
+ ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
+ ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
+ ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
+ int (*iopoll)(struct kiocb *kiocb, bool spin);
+ int (*iterate) (struct file *, struct dir_context *);
+ int (*iterate_shared) (struct file *, struct dir_context *);
+ __poll_t (*poll) (struct file *, struct poll_table_struct *);
+ long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
+ long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
+ int (*mmap) (struct file *, struct vm_area_struct *);
+ int (*open) (struct inode *, struct file *);
+ int (*flush) (struct file *, fl_owner_t id);
+ int (*release) (struct inode *, struct file *);
+ int (*fsync) (struct file *, loff_t, loff_t, int datasync);
+ int (*fasync) (int, struct file *, int);
+ int (*lock) (struct file *, int, struct file_lock *);
+ ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
+ unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
+ int (*check_flags)(int);
+ int (*flock) (struct file *, int, struct file_lock *);
+ ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
+ ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
+ int (*setlease)(struct file *, long, struct file_lock **, void **);
+ long (*fallocate)(struct file *file, int mode, loff_t offset,
+ loff_t len);
+ void (*show_fdinfo)(struct seq_file *m, struct file *f);
+ #ifndef CONFIG_MMU
+ unsigned (*mmap_capabilities)(struct file *);
+ #endif
+ ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int);
+ loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
+ struct file *file_out, loff_t pos_out,
+ loff_t len, unsigned int remap_flags);
+ int (*fadvise)(struct file *, loff_t, loff_t, int);
+ };
Again, all methods are called without any locks being held, unless
otherwise noted.
- llseek: called when the VFS needs to move the file position index
+``llseek``: called when the VFS needs to move the file position index
- read: called by read(2) and related system calls
+``read``: called by read(2) and related system calls
- read_iter: possibly asynchronous read with iov_iter as destination
+``read_iter``: possibly asynchronous read with iov_iter as destination
- write: called by write(2) and related system calls
+``write``: called by write(2) and related system calls
- write_iter: possibly asynchronous write with iov_iter as source
+``write_iter``: possibly asynchronous write with iov_iter as source
- iopoll: called when aio wants to poll for completions on HIPRI iocbs
+``iopoll``: called when aio wants to poll for completions on HIPRI iocbs
- iterate: called when the VFS needs to read the directory contents
+``iterate``: called when the VFS needs to read the directory contents
- iterate_shared: called when the VFS needs to read the directory contents
+``iterate_shared``: called when the VFS needs to read the directory contents
when filesystem supports concurrent dir iterators
- poll: called by the VFS when a process wants to check if there is
+``poll``: called by the VFS when a process wants to check if there is
activity on this file and (optionally) go to sleep until there
is activity. Called by the select(2) and poll(2) system calls
- unlocked_ioctl: called by the ioctl(2) system call.
+``unlocked_ioctl``: called by the ioctl(2) system call.
- compat_ioctl: called by the ioctl(2) system call when 32 bit system calls
+``compat_ioctl``: called by the ioctl(2) system call when 32 bit system calls
are used on 64 bit kernels.
- mmap: called by the mmap(2) system call
+``mmap``: called by the mmap(2) system call
- open: called by the VFS when an inode should be opened. When the VFS
+``open``: called by the VFS when an inode should be opened. When the VFS
opens a file, it creates a new "struct file". It then calls the
open method for the newly allocated file structure. You might
think that the open method really belongs in
@@ -933,40 +945,40 @@ otherwise noted.
"private_data" member in the file structure if you want to point
to a device structure
- flush: called by the close(2) system call to flush a file
+``flush``: called by the close(2) system call to flush a file
- release: called when the last reference to an open file is closed
+``release``: called when the last reference to an open file is closed
- fsync: called by the fsync(2) system call. Also see the section above
+``fsync``: called by the fsync(2) system call. Also see the section above
entitled "Handling errors during writeback".
- fasync: called by the fcntl(2) system call when asynchronous
+``fasync``: called by the fcntl(2) system call when asynchronous
(non-blocking) mode is enabled for a file
- lock: called by the fcntl(2) system call for F_GETLK, F_SETLK, and F_SETLKW
+``lock``: called by the fcntl(2) system call for F_GETLK, F_SETLK, and F_SETLKW
commands
- get_unmapped_area: called by the mmap(2) system call
+``get_unmapped_area``: called by the mmap(2) system call
- check_flags: called by the fcntl(2) system call for F_SETFL command
+``check_flags``: called by the fcntl(2) system call for F_SETFL command
- flock: called by the flock(2) system call
+``flock``: called by the flock(2) system call
- splice_write: called by the VFS to splice data from a pipe to a file. This
+``splice_write``: called by the VFS to splice data from a pipe to a file. This
method is used by the splice(2) system call
- splice_read: called by the VFS to splice data from file to a pipe. This
+``splice_read``: called by the VFS to splice data from file to a pipe. This
method is used by the splice(2) system call
- setlease: called by the VFS to set or release a file lock lease. setlease
+``setlease``: called by the VFS to set or release a file lock lease. setlease
implementations should call generic_setlease to record or remove
the lease in the inode after setting it.
- fallocate: called by the VFS to preallocate blocks or punch a hole.
+``fallocate``: called by the VFS to preallocate blocks or punch a hole.
- copy_file_range: called by the copy_file_range(2) system call.
+``copy_file_range``: called by the copy_file_range(2) system call.
- remap_file_range: called by the ioctl(2) system call for FICLONERANGE and
+``remap_file_range``: called by the ioctl(2) system call for FICLONERANGE and
FICLONE and FIDEDUPERANGE commands to remap file ranges. An
implementation should remap len bytes at pos_in of the source file into
the dest file at pos_out. Implementations must handle callers passing
@@ -979,7 +991,7 @@ otherwise noted.
set, the caller is ok with the implementation shortening the request
length to satisfy alignment or EOF requirements (or any other reason).
- fadvise: possibly called by the fadvise64() system call.
+``fadvise``: possibly called by the fadvise64() system call.
Note that the file operations are implemented by the specific
filesystem in which the inode resides. When opening a device node
@@ -1006,23 +1018,25 @@ here. These methods may be set to NULL, as they are either optional or
the VFS uses a default. As of kernel 2.6.22, the following members are
defined:
-struct dentry_operations {
- int (*d_revalidate)(struct dentry *, unsigned int);
- int (*d_weak_revalidate)(struct dentry *, unsigned int);
- int (*d_hash)(const struct dentry *, struct qstr *);
- int (*d_compare)(const struct dentry *,
- unsigned int, const char *, const struct qstr *);
- int (*d_delete)(const struct dentry *);
- int (*d_init)(struct dentry *);
- void (*d_release)(struct dentry *);
- void (*d_iput)(struct dentry *, struct inode *);
- char *(*d_dname)(struct dentry *, char *, int);
- struct vfsmount *(*d_automount)(struct path *);
- int (*d_manage)(const struct path *, bool);
- struct dentry *(*d_real)(struct dentry *, const struct inode *);
-};
-
- d_revalidate: called when the VFS needs to revalidate a dentry. This
+.. code-block:: c
+
+ struct dentry_operations {
+ int (*d_revalidate)(struct dentry *, unsigned int);
+ int (*d_weak_revalidate)(struct dentry *, unsigned int);
+ int (*d_hash)(const struct dentry *, struct qstr *);
+ int (*d_compare)(const struct dentry *,
+ unsigned int, const char *, const struct qstr *);
+ int (*d_delete)(const struct dentry *);
+ int (*d_init)(struct dentry *);
+ void (*d_release)(struct dentry *);
+ void (*d_iput)(struct dentry *, struct inode *);
+ char *(*d_dname)(struct dentry *, char *, int);
+ struct vfsmount *(*d_automount)(struct path *);
+ int (*d_manage)(const struct path *, bool);
+ struct dentry *(*d_real)(struct dentry *, const struct inode *);
+ };
+
+``d_revalidate``: called when the VFS needs to revalidate a dentry. This
is called whenever a name look-up finds a dentry in the
dcache. Most local filesystems leave this as NULL, because all their
dentries in the dcache are valid. Network filesystems are different
@@ -1041,7 +1055,7 @@ struct dentry_operations {
If a situation is encountered that rcu-walk cannot handle, return
-ECHILD and it will be called again in ref-walk mode.
- d_weak_revalidate: called when the VFS needs to revalidate a "jumped" dentry.
+``_weak_revalidate``: called when the VFS needs to revalidate a "jumped" dentry.
This is called when a path-walk ends at dentry that was not acquired by
doing a lookup in the parent directory. This includes "/", "." and "..",
as well as procfs-style symlinks and mountpoint traversal.
@@ -1055,14 +1069,14 @@ struct dentry_operations {
d_weak_revalidate is only called after leaving rcu-walk mode.
- d_hash: called when the VFS adds a dentry to the hash table. The first
+``d_hash``: called when the VFS adds a dentry to the hash table. The first
dentry passed to d_hash is the parent directory that the name is
to be hashed into.
Same locking and synchronisation rules as d_compare regarding
what is safe to dereference etc.
- d_compare: called to compare a dentry name with a given name. The first
+``d_compare``: called to compare a dentry name with a given name. The first
dentry is the parent of the dentry to be compared, the second is
the child dentry. len and name string are properties of the dentry
to be compared. qstr is the name to compare it with.
@@ -1079,22 +1093,22 @@ struct dentry_operations {
It is a tricky calling convention because it needs to be called under
"rcu-walk", ie. without any locks or references on things.
- d_delete: called when the last reference to a dentry is dropped and the
+``d_delete``: called when the last reference to a dentry is dropped and the
dcache is deciding whether or not to cache it. Return 1 to delete
immediately, or 0 to cache the dentry. Default is NULL which means to
always cache a reachable dentry. d_delete must be constant and
idempotent.
- d_init: called when a dentry is allocated
+``d_init``: called when a dentry is allocated
- d_release: called when a dentry is really deallocated
+``d_release``: called when a dentry is really deallocated
- d_iput: called when a dentry loses its inode (just prior to its
+``d_iput``: called when a dentry loses its inode (just prior to its
being deallocated). The default when this is NULL is that the
VFS calls iput(). If you define this method, you must call
iput() yourself
- d_dname: called when the pathname of a dentry should be generated.
+``d_dname``: called when the pathname of a dentry should be generated.
Useful for some pseudo filesystems (sockfs, pipefs, ...) to delay
pathname generation. (Instead of doing it when dentry is created,
it's done only when the path is needed.). Real filesystems probably
@@ -1108,13 +1122,15 @@ struct dentry_operations {
Example :
+.. code-block:: c
+
static char *pipefs_dname(struct dentry *dent, char *buffer, int buflen)
{
return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
dentry->d_inode->i_ino);
}
- d_automount: called when an automount dentry is to be traversed (optional).
+``d_automount``: called when an automount dentry is to be traversed (optional).
This should create a new VFS mount record and return the record to the
caller. The caller is supplied with a path parameter giving the
automount directory to describe the automount target and the parent
@@ -1134,7 +1150,7 @@ struct dentry_operations {
dentry. This is set by __d_instantiate() if S_AUTOMOUNT is set on the
inode being added.
- d_manage: called to allow the filesystem to manage the transition from a
+``d_manage``: called to allow the filesystem to manage the transition from a
dentry (optional). This allows autofs, for example, to hold up clients
waiting to explore behind a 'mountpoint' while letting the daemon go
past and construct the subtree there. 0 should be returned to let the
@@ -1152,7 +1168,7 @@ struct dentry_operations {
This function is only used if DCACHE_MANAGE_TRANSIT is set on the
dentry being transited from.
- d_real: overlay/union type filesystems implement this method to return one of
+``d_real``: overlay/union type filesystems implement this method to return one of
the underlying dentries hidden by the overlay. It is used in two
different modes:
@@ -1174,36 +1190,36 @@ Directory Entry Cache API
There are a number of functions defined which permit a filesystem to
manipulate dentries:
- dget: open a new handle for an existing dentry (this just increments
+``dget``: open a new handle for an existing dentry (this just increments
the usage count)
- dput: close a handle for a dentry (decrements the usage count). If
+``dput``: close a handle for a dentry (decrements the usage count). If
the usage count drops to 0, and the dentry is still in its
parent's hash, the "d_delete" method is called to check whether
it should be cached. If it should not be cached, or if the dentry
is not hashed, it is deleted. Otherwise cached dentries are put
into an LRU list to be reclaimed on memory shortage.
- d_drop: this unhashes a dentry from its parents hash list. A
+``d_drop``: this unhashes a dentry from its parents hash list. A
subsequent call to dput() will deallocate the dentry if its
usage count drops to 0
- d_delete: delete a dentry. If there are no other open references to
+``d_delete``: delete a dentry. If there are no other open references to
the dentry then the dentry is turned into a negative dentry
(the d_iput() method is called). If there are other
references, then d_drop() is called instead
- d_add: add a dentry to its parents hash list and then calls
+``d_add``: add a dentry to its parents hash list and then calls
d_instantiate()
- d_instantiate: add a dentry to the alias hash list for the inode and
+``d_instantiate``: add a dentry to the alias hash list for the inode and
updates the "d_inode" member. The "i_count" member in the
inode structure should be set/incremented. If the inode
pointer is NULL, the dentry is called a "negative
dentry". This function is commonly called when an inode is
created for an existing negative dentry
- d_lookup: look up a dentry given its parent and path name component
+``d_lookup``: look up a dentry given its parent and path name component
It looks up the child of that given name from the dcache
hash table. If it is found, the reference count is incremented
and the dentry is returned. The caller must use dput()
--
2.21.0
^ permalink raw reply related
* [PATCH v4 8/9] docs: filesystems: vfs: Convert spaces to tabs
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
In-Reply-To: <20190515002913.12586-1-tobin@kernel.org>
There are bunch of places with 8 spaces, in preparation for correctly
indenting all code snippets (during conversion to RST) change these to
use tabspaces.
This patch is whitespace only.
Convert instances of 8 consecutive spaces to a single tabspace.
Signed-off-by: Tobin C. Harding <tobin@kernel.org>
---
Documentation/filesystems/vfs.txt | 124 +++++++++++++++---------------
1 file changed, 62 insertions(+), 62 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 43b18bafbc20..489bbdc6a40f 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -113,12 +113,12 @@ members are defined:
struct file_system_type {
const char *name;
int fs_flags;
- struct dentry *(*mount) (struct file_system_type *, int,
- const char *, void *);
- void (*kill_sb) (struct super_block *);
- struct module *owner;
- struct file_system_type * next;
- struct list_head fs_supers;
+ struct dentry *(*mount) (struct file_system_type *, int,
+ const char *, void *);
+ void (*kill_sb) (struct super_block *);
+ struct module *owner;
+ struct file_system_type * next;
+ struct list_head fs_supers;
struct lock_class_key s_lock_key;
struct lock_class_key s_umount_key;
};
@@ -207,26 +207,26 @@ This describes how the VFS can manipulate the superblock of your
filesystem. As of kernel 2.6.22, the following members are defined:
struct super_operations {
- struct inode *(*alloc_inode)(struct super_block *sb);
- void (*destroy_inode)(struct inode *);
-
- void (*dirty_inode) (struct inode *, int flags);
- int (*write_inode) (struct inode *, int);
- void (*drop_inode) (struct inode *);
- void (*delete_inode) (struct inode *);
- void (*put_super) (struct super_block *);
- int (*sync_fs)(struct super_block *sb, int wait);
- int (*freeze_fs) (struct super_block *);
- int (*unfreeze_fs) (struct super_block *);
- int (*statfs) (struct dentry *, struct kstatfs *);
- int (*remount_fs) (struct super_block *, int *, char *);
- void (*clear_inode) (struct inode *);
- void (*umount_begin) (struct super_block *);
-
- int (*show_options)(struct seq_file *, struct dentry *);
-
- ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
- ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
+ struct inode *(*alloc_inode)(struct super_block *sb);
+ void (*destroy_inode)(struct inode *);
+
+ void (*dirty_inode) (struct inode *, int flags);
+ int (*write_inode) (struct inode *, int);
+ void (*drop_inode) (struct inode *);
+ void (*delete_inode) (struct inode *);
+ void (*put_super) (struct super_block *);
+ int (*sync_fs)(struct super_block *sb, int wait);
+ int (*freeze_fs) (struct super_block *);
+ int (*unfreeze_fs) (struct super_block *);
+ int (*statfs) (struct dentry *, struct kstatfs *);
+ int (*remount_fs) (struct super_block *, int *, char *);
+ void (*clear_inode) (struct inode *);
+ void (*umount_begin) (struct super_block *);
+
+ int (*show_options)(struct seq_file *, struct dentry *);
+
+ ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
+ ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
int (*nr_cached_objects)(struct super_block *);
void (*free_cached_objects)(struct super_block *, int);
};
@@ -475,7 +475,7 @@ otherwise noted.
filesystem.
May be called in rcu-walk mode (mask & MAY_NOT_BLOCK). If in rcu-walk
- mode, the filesystem must check the permission without blocking or
+ mode, the filesystem must check the permission without blocking or
storing to the inode.
If a situation is encountered that rcu-walk cannot handle, return
@@ -694,12 +694,12 @@ struct address_space_operations {
tagged as DIRTY and will pass them to ->writepage.
set_page_dirty: called by the VM to set a page dirty.
- This is particularly needed if an address space attaches
- private data to a page, and that data needs to be updated when
- a page is dirtied. This is called, for example, when a memory
+ This is particularly needed if an address space attaches
+ private data to a page, and that data needs to be updated when
+ a page is dirtied. This is called, for example, when a memory
mapped page gets modified.
If defined, it should set the PageDirty flag, and the
- PAGECACHE_TAG_DIRTY tag in the radix tree.
+ PAGECACHE_TAG_DIRTY tag in the radix tree.
readpages: called by the VM to read pages associated with the address_space
object. This is essentially just a vector version of
@@ -717,7 +717,7 @@ struct address_space_operations {
storage, then those blocks should be pre-read (if they haven't been
read already) so that the updated blocks can be written out properly.
- The filesystem must return the locked pagecache page for the specified
+ The filesystem must return the locked pagecache page for the specified
offset, in *pagep, for the caller to write into.
It must be able to cope with short writes (where the length passed to
@@ -726,21 +726,21 @@ struct address_space_operations {
flags is a field for AOP_FLAG_xxx flags, described in
include/linux/fs.h.
- A void * may be returned in fsdata, which then gets passed into
- write_end.
+ A void * may be returned in fsdata, which then gets passed into
+ write_end.
- Returns 0 on success; < 0 on failure (which is the error code), in
+ Returns 0 on success; < 0 on failure (which is the error code), in
which case write_end is not called.
write_end: After a successful write_begin, and data copy, write_end must
- be called. len is the original len passed to write_begin, and copied
- is the amount that was able to be copied.
+ be called. len is the original len passed to write_begin, and copied
+ is the amount that was able to be copied.
- The filesystem must take care of unlocking the page and releasing it
- refcount, and updating i_size.
+ The filesystem must take care of unlocking the page and releasing it
+ refcount, and updating i_size.
- Returns < 0 on failure, otherwise the number of bytes (<= 'copied')
- that were able to be copied into pagecache.
+ Returns < 0 on failure, otherwise the number of bytes (<= 'copied')
+ that were able to be copied into pagecache.
bmap: called by the VFS to map a logical block offset within object to
physical block number. This method is used by the FIBMAP
@@ -751,7 +751,7 @@ struct address_space_operations {
are and uses those addresses directly.
invalidatepage: If a page has PagePrivate set, then invalidatepage
- will be called when part or all of the page is to be removed
+ will be called when part or all of the page is to be removed
from the address space. This generally corresponds to either a
truncation, punch hole or a complete invalidation of the address
space (in the latter case 'offset' will always be 0 and 'length'
@@ -763,47 +763,47 @@ struct address_space_operations {
release MUST succeed.
releasepage: releasepage is called on PagePrivate pages to indicate
- that the page should be freed if possible. ->releasepage
- should remove any private data from the page and clear the
- PagePrivate flag. If releasepage() fails for some reason, it must
+ that the page should be freed if possible. ->releasepage
+ should remove any private data from the page and clear the
+ PagePrivate flag. If releasepage() fails for some reason, it must
indicate failure with a 0 return value.
releasepage() is used in two distinct though related cases. The
first is when the VM finds a clean page with no active users and
- wants to make it a free page. If ->releasepage succeeds, the
- page will be removed from the address_space and become free.
+ wants to make it a free page. If ->releasepage succeeds, the
+ page will be removed from the address_space and become free.
The second case is when a request has been made to invalidate
- some or all pages in an address_space. This can happen
- through the fadvise(POSIX_FADV_DONTNEED) system call or by the
- filesystem explicitly requesting it as nfs and 9fs do (when
- they believe the cache may be out of date with storage) by
- calling invalidate_inode_pages2().
+ some or all pages in an address_space. This can happen
+ through the fadvise(POSIX_FADV_DONTNEED) system call or by the
+ filesystem explicitly requesting it as nfs and 9fs do (when
+ they believe the cache may be out of date with storage) by
+ calling invalidate_inode_pages2().
If the filesystem makes such a call, and needs to be certain
- that all pages are invalidated, then its releasepage will
- need to ensure this. Possibly it can clear the PageUptodate
- bit if it cannot free private data yet.
+ that all pages are invalidated, then its releasepage will
+ need to ensure this. Possibly it can clear the PageUptodate
+ bit if it cannot free private data yet.
freepage: freepage is called once the page is no longer visible in
- the page cache in order to allow the cleanup of any private
+ the page cache in order to allow the cleanup of any private
data. Since it may be called by the memory reclaimer, it
should not assume that the original address_space mapping still
exists, and it should not block.
direct_IO: called by the generic read/write routines to perform
- direct_IO - that is IO requests which bypass the page cache
- and transfer data directly between the storage and the
- application's address space.
+ direct_IO - that is IO requests which bypass the page cache
+ and transfer data directly between the storage and the
+ application's address space.
isolate_page: Called by the VM when isolating a movable non-lru page.
If page is successfully isolated, VM marks the page as PG_isolated
via __SetPageIsolated.
migrate_page: This is used to compact the physical memory usage.
- If the VM wants to relocate a page (maybe off a memory card
- that is signalling imminent failure) it will pass a new page
+ If the VM wants to relocate a page (maybe off a memory card
+ that is signalling imminent failure) it will pass a new page
and an old page to this function. migrate_page should
transfer any private data across and update any references
- that it has to the page.
+ that it has to the page.
putback_page: Called by the VM when isolated page's migration fails.
--
2.21.0
^ permalink raw reply related
* [PATCH v4 0/9] docs: Convert VFS doc to RST
From: Tobin C. Harding @ 2019-05-15 0:29 UTC (permalink / raw)
To: Jonathan Corbet
Cc: Tobin C. Harding, Al Viro, Mauro Carvalho Chehab, Neil Brown,
Randy Dunlap, linux-doc, linux-fsdevel, linux-kernel
Hi Jon,
Here is an updated version of the VFS doc conversion. This series in no
way represents a final point for the VFS documentation rather it is a
small step towards getting VFS docs updated. This series does not
update the content of vfs.txt, only does formatting.
Testing: the following produces no new build warnings
make cleandocs
make htmldocs 2> pre.stderr
# apply this patch series
make cleandocs
make htmldocs 2> post.stderr
diff pre.stderr post.stderr
thanks,
Tobin.
Tobin C. Harding (9):
docs: filesystems: vfs: Remove space before tab
docs: filesystems: vfs: Use uniform space after period.
docs: filesystems: vfs: Use 72 character column width
docs: filesystems: vfs: Use uniform spacing around headings
docs: filesystems: vfs: Use correct initial heading
docs: filesystems: vfs: Use SPDX identifier
docs: filesystems: vfs: Fix pre-amble indentation
docs: filesystems: vfs: Convert spaces to tabs
docs: filesystems: vfs: Convert vfs.txt to RST
Documentation/filesystems/index.rst | 1 +
Documentation/filesystems/vfs.rst | 1286 +++++++++++++++++++++++++++
Documentation/filesystems/vfs.txt | 1264 --------------------------
3 files changed, 1287 insertions(+), 1264 deletions(-)
create mode 100644 Documentation/filesystems/vfs.rst
delete mode 100644 Documentation/filesystems/vfs.txt
--
2.21.0
^ permalink raw reply
* Re: [PATCH v2 00/17] kunit: introduce KUnit, the Linux kernel unit testing framework
From: Logan Gunthorpe @ 2019-05-15 0:26 UTC (permalink / raw)
To: Frank Rowand, Brendan Higgins
Cc: Theodore Ts'o, Tim.Bird, knut.omang, gregkh, keescook,
kieran.bingham, mcgrof, robh, sboyd, shuah, devicetree, dri-devel,
kunit-dev, linux-doc, linux-fsdevel, linux-kbuild, linux-kernel,
linux-kselftest, linux-nvdimm, linux-um, Alexander.Levin,
amir73il, dan.carpenter, dan.j.williams, daniel, jdike, joel,
julia.lawall, khilman, mpe, pmladek, richard, rientjes, rostedt,
wfg
In-Reply-To: <5ff098a9-9424-901c-9017-d4492e306528@gmail.com>
On 2019-05-14 6:14 p.m., Frank Rowand wrote:
> The high level issue is to provide reviewers with enough context to be
> able to evaluate the patch series. That is probably not very obvious
> at this point in the thread. At this point I was responding to Logan's
> response to me that I should be reading Documentation to get a better
> description of KUnit features. I _think_ that Logan thought that I
> did not understand KUnit features and was trying to be helpful by
> pointing out where I could get more information. If so, he was missing
> my intended point had been that patch 0 should provide more information
> to justify adding this feature.
Honestly, I lost track of wait exactly your point was. And, in my
opinion, Brendan has provided over and above the information required to
justify Kunit's inclusion.
> One thing that has become very apparent in the discussion of this patch
> series is that some people do not understand that kselftest includes
> in-kernel tests, not just userspace tests. As such, KUnit is an
> additional implementation of "the same feature". (One can debate
> exactly which in-kernel test features kselftest and KUnit provide,
> and how much overlap exists or does not exist. So don't take "the
> same feature" as my final opinion of how much overlap exists.) So
> that is a key element to be noted and explained.
From my perspective, once we were actually pointed to the in-kernel
kselftest code and took a look at it, it was clear there was no
over-arching framework to them and that Kunit could be used to
significantly improve those tests with a common structure. Based on my
reading of the thread, Ted came to the same conclusion.
I don't think we should block this feature from being merged, and for
future work, someone can update the in-kernel kselftests to use the new
framework.
Logan
^ permalink raw reply
* Re: [PATCH v2 00/17] kunit: introduce KUnit, the Linux kernel unit testing framework
From: Frank Rowand @ 2019-05-15 0:26 UTC (permalink / raw)
To: Theodore Ts'o, Tim.Bird, knut.omang, gregkh, brendanhiggins,
keescook, kieran.bingham, mcgrof, robh, sboyd, shuah, devicetree,
dri-devel, kunit-dev, linux-doc, linux-fsdevel, linux-kbuild,
linux-kernel, linux-kselftest, linux-nvdimm, linux-um,
Alexander.Levin, amir73il, dan.carpenter, dan.j.williams, daniel,
jdike, joel, julia.lawall, khilman, logang, mpe, pmladek, richard,
rientjes, rostedt, wfg
In-Reply-To: <20190511173344.GA8507@mit.edu>
On 5/11/19 10:33 AM, Theodore Ts'o wrote:
> On Fri, May 10, 2019 at 02:12:40PM -0700, Frank Rowand wrote:
>> However, the reply is incorrect. Kselftest in-kernel tests (which
>> is the context here) can be configured as built in instead of as
>> a module, and built in a UML kernel. The UML kernel can boot,
>> running the in-kernel tests before UML attempts to invoke the
>> init process.
>
> Um, Citation needed?
The paragraph that you quoted tells you exactly how to run a kselftest
in-kernel test in a UML kernel. Just to what that paragraph says.
>
> I don't see any evidence for this in the kselftest documentation, nor
> do I see any evidence of this in the kselftest Makefiles.
>
> There exists test modules in the kernel that run before the init
> scripts run --- but that's not strictly speaking part of kselftests,
> and do not have any kind of infrastructure. As noted, the
> kselftests_harness header file fundamentally assumes that you are
> running test code in userspace.
You are ignoring the kselftest in-kernel tests.
We are talking in circles. I'm done with this thread.
-Frank
>
> - Ted
> .
>
^ permalink raw reply
* Re: [PATCH v2 00/17] kunit: introduce KUnit, the Linux kernel unit testing framework
From: Frank Rowand @ 2019-05-15 0:14 UTC (permalink / raw)
To: Brendan Higgins
Cc: Logan Gunthorpe, Theodore Ts'o, Tim.Bird, knut.omang, gregkh,
keescook, kieran.bingham, mcgrof, robh, sboyd, shuah, devicetree,
dri-devel, kunit-dev, linux-doc, linux-fsdevel, linux-kbuild,
linux-kernel, linux-kselftest, linux-nvdimm, linux-um,
Alexander.Levin, amir73il, dan.carpenter, dan.j.williams, daniel,
jdike, joel, julia.lawall, khilman, mpe, pmladek, richard,
rientjes, rostedt, wfg
In-Reply-To: <20190514083819.GC230665@google.com>
On 5/14/19 1:38 AM, Brendan Higgins wrote:
> On Fri, May 10, 2019 at 03:13:40PM -0700, Frank Rowand wrote:
>> On 5/10/19 9:17 AM, Logan Gunthorpe wrote:
>>>
>>>
>>> On 2019-05-09 11:18 p.m., Frank Rowand wrote:
>>>
>>>> YES, kselftest has in-kernel tests. (Excuse the shouting...)
>>>
>>> Cool. From my cursory look, in my opinion, these would be greatly
>>> improved by converting them to the framework Brendan is proposing for Kunit.
>>>
>>>>> If they do exists, it seems like it would make sense to
>>>>> convert those to kunit and have Kunit tests run-able in a VM or
>>>>> baremetal instance.
>>>>
>>>> They already run in a VM.
>>>>
>>>> They already run on bare metal.
>>>>
>>>> They already run in UML.
>>>
>>> Simply being able to run in UML is not the only thing here. Kunit
>>> provides the infrastructure to quickly build, run and report results for
>>> all the tests from userspace without needing to worry about the details
>>> of building and running a UML kernel, then parsing dmesg to figure out
>>> what tests were run or not.
>>
>> Yes. But that is not the only environment that KUnit must support to be
>> of use to me for devicetree unittests (this is not new, Brendan is quite
>> aware of my needs and is not ignoring them).
>>
>>
>>>> This is not to say that KUnit does not make sense. But I'm still trying
>>>> to get a better description of the KUnit features (and there are
>>>> some).
>>>
>>> So read the patches, or the documentation[1] or the LWN article[2]. It's
>>> pretty well described in a lot of places -- that's one of the big
>>> advantages of it. In contrast, few people seems to have any concept of
>>> what kselftests are or where they are or how to run them (I was
>>> surprised to find the in-kernel tests in the lib tree).
>>>
>>> Logan
>>>
>>> [1] https://google.github.io/kunit-docs/third_party/kernel/docs/
>>> [2] https://lwn.net/Articles/780985/
>>
>> I have been following the RFC versions. I have installed the RFC patches
>> and run them to the extent that they worked (devicetree unittests were
>> a guinea pig for test conversion in the RFC series, but the converted
>> tests did not work). I read portions of the code while trying to
>> understand the unittests conversion. I made review comments based on
>> the portion of the code that I did read. I have read the documentation
>> (very nice btw, as I have said before, but should be expanded).
>>
>> My comment is that the description to submit the patch series should
>> be fuller -- KUnit potentially has a lot of nice attributes, and I
>> still think I have only scratched the surface. The average reviewer
>> may have even less in-depth knowledge than I do. And as I have
>> commented before, I keep diving into areas that I had no previous
>> experience with (such as kselftest) to be able to properly judge this
>> patch series.
>
> Thanks for the praise! That means a lot coming from you!
>
> I really cannot disagree that I could use more documentation. You can
> pretty much always use more documentation. Nevertheless, is there a
> particular part of the documentation that you think it lacking?
I wasn't talking about the documentation that is part of KUnit. I was
targeting patch 0.
> It sounds like there was a pretty long discussion here about, a number
> of different things.
>
> Do you want a better description of what unit testing is and how KUnit
> helps make it possible?
>
> Do you want more of an explanation distinguishing KUnit from kselftest?
> How so?
The high level issue is to provide reviewers with enough context to be
able to evaluate the patch series. That is probably not very obvious
at this point in the thread. At this point I was responding to Logan's
response to me that I should be reading Documentation to get a better
description of KUnit features. I _think_ that Logan thought that I
did not understand KUnit features and was trying to be helpful by
pointing out where I could get more information. If so, he was missing
my intended point had been that patch 0 should provide more information
to justify adding this feature.
One thing that has become very apparent in the discussion of this patch
series is that some people do not understand that kselftest includes
in-kernel tests, not just userspace tests. As such, KUnit is an
additional implementation of "the same feature". (One can debate
exactly which in-kernel test features kselftest and KUnit provide,
and how much overlap exists or does not exist. So don't take "the
same feature" as my final opinion of how much overlap exists.) So
that is a key element to be noted and explained.
I don't have a goal of finding all the things to include in patch 0,
that is really your job as the patch submitter. But as a reviewer,
it is easy for me to point out an obvious hole, even if I don't find
all of the holes. kselftest vs KUnit overlap was an obvious hole to
me.
So, yes, more of an explanation about the in-kernel testing available
via kselftest vs the in-kernel testing available via KUnit, and how
they provide the same or different functionality. Should both exist?
Should one replace the other? If one provides additional features,
should the additional features be merged into a common base?
> Do you just want better documentation on how to test the kernel? What
> tools we have at our disposal and when to use what tools?
>
> Thanks!
> .
>
^ permalink raw reply
* Re: [LTP] [EXT] Re: [PATCH v9 00/24] ILP32 for ARM64
From: Yury Norov @ 2019-05-14 23:41 UTC (permalink / raw)
To: Cyril Hrubis
Cc: Yuri Norov, Andreas Schwab, ltp@lists.linux.it,
linux-doc@vger.kernel.org, Szabolcs Nagy, Catalin Marinas,
Heiko Carstens, Philipp Tomsich, Joseph Myers,
linux-arch@vger.kernel.org, Steve Ellcey, Prasun Kapoor,
Alexander Graf, Bamvor Zhangjian, Geert Uytterhoeven, Dave Martin,
Adam Borowski, Manuel Montezelo, James Hogan, Chris Metcalf,
Arnd Bergmann, Andrew Pinski, Lin Yongting, Alexey Klimov,
Mark Brown, linux-arm-kernel@lists.infradead.org, Maxim Kuvyrkov,
Florian Weimer, linux-api@vger.kernel.org, Nathan_Lynch,
linux-kernel@vger.kernel.org, Ramana Radhakrishnan,
Martin Schwidefsky, David S . Miller, Christoph Muellner
In-Reply-To: <20190514104311.GA24708@rei>
On Tue, May 14, 2019 at 12:43:11PM +0200, Cyril Hrubis wrote:
> Hi!
> > > There is a problem with the stack size accounting during execve when
> > > there is no stack limit:
> > >
> > > $ ulimit -s
> > > 8192
> > > $ ./hello.ilp32
> > > Hello World!
> > > $ ulimit -s unlimited
> > > $ ./hello.ilp32
> > > Segmentation fault
> > > $ strace ./hello.ilp32
> > > execve("./hello.ilp32", ["./hello.ilp32"], 0xfffff10548f0 /* 77 vars */) = -1 ENOMEM (Cannot allocate memory)
> > > +++ killed by SIGSEGV +++
> > > Segmentation fault (core dumped)
> > >
> > > Andreas.
> >
> > Thanks Andreas, I will take a look. Do we have such test in LTP?
>
> We do have a test that we can run a binary with very small stack size
> i.e. 512kB but there does not seem to be anything that would catch this
> specific problem.
>
> Can you please open an issue and describe how to reproduce the problem
> at our github tracker:
>
> https://github.com/linux-test-project/ltp/issues
>
> Then we can create testcase based on that reproducer later on.
This is it:
https://github.com/linux-test-project/ltp/issues/530
Yury
^ permalink raw reply
* Re: [PATCH v4 16/18] MAINTAINERS: add entry for KUnit the unit testing framework
From: Brendan Higgins @ 2019-05-14 23:25 UTC (permalink / raw)
To: frowand.list, gregkh, jpoimboe, keescook, kieran.bingham, mcgrof,
peterz, robh, sboyd, shuah, tytso, yamada.masahiro
Cc: devicetree, dri-devel, kunit-dev, linux-doc, linux-fsdevel,
linux-kbuild, linux-kernel, linux-kselftest, linux-nvdimm,
linux-um, Alexander.Levin, Tim.Bird, amir73il, dan.carpenter,
daniel, jdike, joel, julia.lawall, khilman, knut.omang, logang,
mpe, pmladek, rdunlap, richard, rientjes, rostedt, wfg
In-Reply-To: <20190514221711.248228-17-brendanhiggins@google.com>
On Tue, May 14, 2019 at 03:17:09PM -0700, Brendan Higgins wrote:
> Add myself as maintainer of KUnit, the Linux kernel's unit testing
> framework.
>
> Signed-off-by: Brendan Higgins <brendanhiggins@google.com>
> Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
> Reviewed-by: Logan Gunthorpe <logang@deltatee.com>
> ---
> MAINTAINERS | 11 +++++++++++
> 1 file changed, 11 insertions(+)
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 2c2fce72e694f..8a91887c8d541 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -8448,6 +8448,17 @@ S: Maintained
> F: tools/testing/selftests/
> F: Documentation/dev-tools/kselftest*
>
> +KERNEL UNIT TESTING FRAMEWORK (KUnit)
> +M: Brendan Higgins <brendanhiggins@google.com>
> +L: linux-kselftest@vger.kernel.org
> +L: kunit-dev@googlegroups.com
> +W: https://google.github.io/kunit-docs/third_party/kernel/docs/
> +S: Maintained
> +F: Documentation/kunit/
Dang it! I forgot to update the documentation path...
Will fix in next revision.
> +F: include/kunit/
> +F: kunit/
> +F: tools/testing/kunit/
> +
> KERNEL USERMODE HELPER
> M: Luis Chamberlain <mcgrof@kernel.org>
> L: linux-kernel@vger.kernel.org
> --
> 2.21.0.1020.gf2820cf01a-goog
>
^ permalink raw reply
* Re: [PATCH v3 15/18] Documentation: kunit: add documentation for KUnit
From: Brendan Higgins @ 2019-05-14 23:19 UTC (permalink / raw)
To: Jonathan Corbet
Cc: frowand.list, gregkh, keescook, kieran.bingham, mcgrof, robh,
sboyd, shuah, tytso, yamada.masahiro, devicetree, dri-devel,
kunit-dev, linux-doc, linux-fsdevel, linux-kbuild, linux-kernel,
linux-kselftest, linux-nvdimm, linux-um, Alexander.Levin,
Tim.Bird, amir73il, dan.carpenter, dan.j.williams, daniel, jdike,
joel, julia.lawall, khilman, knut.omang, logang, mpe, pmladek,
rdunlap, richard, rientjes, rostedt, wfg, Felix Guo
In-Reply-To: <20190514121623.0314bf07@lwn.net>
On Tue, May 14, 2019 at 12:16:23PM -0600, Jonathan Corbet wrote:
> On Tue, 14 May 2019 11:08:10 -0700
> Brendan Higgins <brendanhiggins@google.com> wrote:
>
> > > Naturally, though, I have one request: I'd rather not see this at the top
> > > level, which is more than crowded enough as it is. Can this material
> > > please go into the development tools book, alongside the kselftest
> > > documentation?
Hmmm...probably premature to bring this up, but Documentation/dev-tools/
is kind of thrown together.
It would be nice to provide a coherent overview, maybe provide some
basic grouping as well.
It would be nice if there was kind of a gentle introduction to the
tools, which ones you should be looking at, when, why, etc.
> > Oh yeah, that seems like the obvious home for this in hindsight. Sorry
> > about that. Will fix in next revision!
>
> No need to apologize - I have to say the same thing to everybody :)
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox