Quelle  papr-rtas-common.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only

#define pr_fmt(fmt) "papr-common: " fmt

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/anon_inodes.h>
#include <linux/sched/signal.h>
#include "papr-rtas-common.h"

/*
 * Sequence based RTAS HCALL has to issue multiple times to retrieve
 * complete data from the hypervisor. For some of these RTAS calls,
 * the OS should not interleave calls with different input until the
 * sequence is completed. So data is collected for these calls during
 * ioctl handle and export to user space with read() handle.
 * This file provides common functions needed for such sequence based
 * RTAS calls Ex: ibm,get-vpd and ibm,get-indices.
 */

bool papr_rtas_blob_has_data(const struct papr_rtas_blob *blob)
{
 return blob->data && blob->len;
}

void papr_rtas_blob_free(const struct papr_rtas_blob *blob)
{
 if (blob) {
  kvfree(blob->data);
  kfree(blob);
 }
}

/**
 * papr_rtas_blob_extend() - Append data to a &struct papr_rtas_blob.
 * @blob: The blob to extend.
 * @data: The new data to append to @blob.
 * @len:  The length of @data.
 *
 * Context: May sleep.
 * Return: -ENOMEM on allocation failure, 0 otherwise.
 */
static int papr_rtas_blob_extend(struct papr_rtas_blob *blob,
    const char *data, size_t len)
{
 const size_t new_len = blob->len + len;
 const size_t old_len = blob->len;
 const char *old_ptr = blob->data;
 char *new_ptr;

 new_ptr = kvrealloc(old_ptr, new_len, GFP_KERNEL_ACCOUNT);
 if (!new_ptr)
  return -ENOMEM;

 memcpy(&new_ptr[old_len], data, len);
 blob->data = new_ptr;
 blob->len = new_len;
 return 0;
}

/**
 * papr_rtas_blob_generate() - Construct a new &struct papr_rtas_blob.
 * @seq: work function of the caller that is called to obtain
 *       data with the caller RTAS call.
 *
 * The @work callback is invoked until it returns NULL. @seq is
 * passed to @work in its first argument on each call. When
 * @work returns data, it should store the data length in its
 * second argument.
 *
 * Context: May sleep.
 * Return: A completely populated &struct papr_rtas_blob, or NULL on error.
 */
static const struct papr_rtas_blob *
papr_rtas_blob_generate(struct papr_rtas_sequence *seq)
{
 struct papr_rtas_blob *blob;
 const char *buf;
 size_t len;
 int err = 0;

 blob  = kzalloc(sizeof(*blob), GFP_KERNEL_ACCOUNT);
 if (!blob)
  return NULL;

 if (!seq->work)
  return ERR_PTR(-EINVAL);


 while (err == 0 && (buf = seq->work(seq, &len)))
  err = papr_rtas_blob_extend(blob, buf, len);

 if (err != 0 || !papr_rtas_blob_has_data(blob))
  goto free_blob;

 return blob;
free_blob:
 papr_rtas_blob_free(blob);
 return NULL;
}

int papr_rtas_sequence_set_err(struct papr_rtas_sequence *seq, int err)
{
 /* Preserve the first error recorded. */
 if (seq->error == 0)
  seq->error = err;

 return seq->error;
}

/*
 * Higher-level retrieval code below. These functions use the
 * papr_rtas_blob_* and sequence_* APIs defined above to create fd-based
 * handles for consumption by user space.
 */

/**
 * papr_rtas_run_sequence() - Run a single retrieval sequence.
 * @seq: Functions of the caller to complete the sequence
 *
 * Context: May sleep. Holds a mutex and an RTAS work area for its
 *          duration. Typically performs multiple sleepable slab
 *          allocations.
 *
 * Return: A populated &struct papr_rtas_blob on success. Encoded error
 * pointer otherwise.
 */
static const struct papr_rtas_blob *papr_rtas_run_sequence(struct papr_rtas_sequence *seq)
{
 const struct papr_rtas_blob *blob;

 if (seq->begin)
  seq->begin(seq);

 blob = papr_rtas_blob_generate(seq);
 if (!blob)
  papr_rtas_sequence_set_err(seq, -ENOMEM);

 if (seq->end)
  seq->end(seq);


 if (seq->error) {
  papr_rtas_blob_free(blob);
  return ERR_PTR(seq->error);
 }

 return blob;
}

/**
 * papr_rtas_retrieve() - Return the data blob that is exposed to
 * user space.
 * @seq: RTAS call specific functions to be invoked until the
 *       sequence is completed.
 *
 * Run sequences against @param until a blob is successfully
 * instantiated, or a hard error is encountered, or a fatal signal is
 * pending.
 *
 * Context: May sleep.
 * Return: A fully populated data blob when successful. Encoded error
 * pointer otherwise.
 */
const struct papr_rtas_blob *papr_rtas_retrieve(struct papr_rtas_sequence *seq)
{
 const struct papr_rtas_blob *blob;

 /*
 * EAGAIN means the sequence returns error with a -4 (data
 * changed and need to start the sequence) status from RTAS calls
 * and we should attempt a new sequence. PAPR+ (v2.13 R1–7.3.20–5
 * - ibm,get-vpd, R1–7.3.17–6 - ibm,get-indices) indicates that
 * this should be a transient condition, not something that
 * happens continuously. But we'll stop trying on a fatal signal.
 */
 do {
  blob = papr_rtas_run_sequence(seq);
  if (!IS_ERR(blob)) /* Success. */
   break;
  if (PTR_ERR(blob) != -EAGAIN) /* Hard error. */
   break;
  cond_resched();
 } while (!fatal_signal_pending(current));

 return blob;
}

/**
 * papr_rtas_setup_file_interface - Complete the sequence and obtain
 * the data and export to user space with fd-based handles. Then the
 * user spave gets the data with read() handle.
 * @seq: RTAS call specific functions to get the data.
 * @fops: RTAS call specific file operations such as read().
 * @name: RTAS call specific char device node.
 *
 * Return: FD handle for consumption by user space
 */
long papr_rtas_setup_file_interface(struct papr_rtas_sequence *seq,
    const struct file_operations *fops,
    char *name)
{
 const struct papr_rtas_blob *blob;
 struct file *file;
 long ret;
 int fd;

 blob = papr_rtas_retrieve(seq);
 if (IS_ERR(blob))
  return PTR_ERR(blob);

 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
 if (fd < 0) {
  ret = fd;
  goto free_blob;
 }

 file = anon_inode_getfile_fmode(name, fops, (void *)blob,
   O_RDONLY, FMODE_LSEEK | FMODE_PREAD);
 if (IS_ERR(file)) {
  ret = PTR_ERR(file);
  goto put_fd;
 }

 fd_install(fd, file);
 return fd;

put_fd:
 put_unused_fd(fd);
free_blob:
 papr_rtas_blob_free(blob);
 return ret;
}

/*
 * papr_rtas_sequence_should_stop() - Determine whether RTAS retrieval
 *                                    sequence should continue.
 *
 * Examines the sequence error state and outputs of the last call to
 * the specific RTAS to determine whether the sequence in progress
 * should continue or stop.
 *
 * Return: True if the sequence has encountered an error or if all data
 *         for this sequence has been retrieved. False otherwise.
 */
bool papr_rtas_sequence_should_stop(const struct papr_rtas_sequence *seq,
    s32 status, bool init_state)
{
 bool done;

 if (seq->error)
  return true;

 switch (status) {
 case RTAS_SEQ_COMPLETE:
  if (init_state)
   done = false; /* Initial state. */
  else
   done = true; /* All data consumed. */
  break;
 case RTAS_SEQ_MORE_DATA:
  done = false; /* More data available. */
  break;
 default:
  done = true; /* Error encountered. */
  break;
 }

 return done;
}

/*
 * User space read to retrieve data for the corresponding RTAS call.
 * papr_rtas_blob is filled with the data using the corresponding RTAS
 * call sequence API.
 */
ssize_t papr_rtas_common_handle_read(struct file *file,
        char __user *buf, size_t size, loff_t *off)
{
 const struct papr_rtas_blob *blob = file->private_data;

 /* We should not instantiate a handle without any data attached. */
 if (!papr_rtas_blob_has_data(blob)) {
  pr_err_once("handle without data\n");
  return -EIO;
 }

 return simple_read_from_buffer(buf, size, off, blob->data, blob->len);
}

int papr_rtas_common_handle_release(struct inode *inode,
  struct file *file)
{
 const struct papr_rtas_blob *blob = file->private_data;

 papr_rtas_blob_free(blob);

 return 0;
}

loff_t papr_rtas_common_handle_seek(struct file *file, loff_t off,
     int whence)
{
 const struct papr_rtas_blob *blob = file->private_data;

 return fixed_size_llseek(file, off, whence, blob->len);
}