// SPDX-License-Identifier: GPL-2.0-only
  /*
   * Coredump functionality for Remoteproc framework.
   *
   * Copyright (c) 2020, The Linux Foundation. All rights reserved.
   */

  #include <linux/completion.h>

  #include <linux/devcoredump.h>
  #include <linux/device.h>
  #include <linux/kernel.h>
  #include <linux/remoteproc.h>
  #include "remoteproc_internal.h"
  #include "remoteproc_elf_helpers.h"

  struct rproc_coredump_state {
  	struct rproc *rproc;
  	void *header;
  	struct completion dump_done;
  };

  /**
   * rproc_coredump_cleanup() - clean up dump_segments list
   * @rproc: the remote processor handle
   */
  void rproc_coredump_cleanup(struct rproc *rproc)
  {
  	struct rproc_dump_segment *entry, *tmp;
  
  	list_for_each_entry_safe(entry, tmp, &rproc->dump_segments, node) {
  		list_del(&entry->node);
  		kfree(entry);
  	}
  }
  
  /**
   * rproc_coredump_add_segment() - add segment of device memory to coredump
   * @rproc:	handle of a remote processor
   * @da:		device address
   * @size:	size of segment
   *
   * Add device memory to the list of segments to be included in a coredump for
   * the remoteproc.
   *
   * Return: 0 on success, negative errno on error.
   */
  int rproc_coredump_add_segment(struct rproc *rproc, dma_addr_t da, size_t size)
  {
  	struct rproc_dump_segment *segment;
  
  	segment = kzalloc(sizeof(*segment), GFP_KERNEL);
  	if (!segment)
  		return -ENOMEM;
  
  	segment->da = da;
  	segment->size = size;
  
  	list_add_tail(&segment->node, &rproc->dump_segments);
  
  	return 0;
  }
  EXPORT_SYMBOL(rproc_coredump_add_segment);
  
  /**
   * rproc_coredump_add_custom_segment() - add custom coredump segment
   * @rproc:	handle of a remote processor
   * @da:		device address
   * @size:	size of segment
   * @dumpfn:	custom dump function called for each segment during coredump
   * @priv:	private data
   *
   * Add device memory to the list of segments to be included in the coredump
   * and associate the segment with the given custom dump function and private
   * data.
   *
   * Return: 0 on success, negative errno on error.
   */
  int rproc_coredump_add_custom_segment(struct rproc *rproc,
  				      dma_addr_t da, size_t size,
  				      void (*dumpfn)(struct rproc *rproc,
  						     struct rproc_dump_segment *segment,

  						     void *dest, size_t offset,
  						     size_t size),

  				      void *priv)
  {
  	struct rproc_dump_segment *segment;
  
  	segment = kzalloc(sizeof(*segment), GFP_KERNEL);
  	if (!segment)
  		return -ENOMEM;
  
  	segment->da = da;
  	segment->size = size;
  	segment->priv = priv;
  	segment->dump = dumpfn;
  
  	list_add_tail(&segment->node, &rproc->dump_segments);
  
  	return 0;
  }
  EXPORT_SYMBOL(rproc_coredump_add_custom_segment);
  
  /**
   * rproc_coredump_set_elf_info() - set coredump elf information
   * @rproc:	handle of a remote processor
   * @class:	elf class for coredump elf file
   * @machine:	elf machine for coredump elf file
   *
   * Set elf information which will be used for coredump elf file.
   *
   * Return: 0 on success, negative errno on error.
   */
  int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine)
  {
  	if (class != ELFCLASS64 && class != ELFCLASS32)
  		return -EINVAL;
  
  	rproc->elf_class = class;
  	rproc->elf_machine = machine;
  
  	return 0;
  }
  EXPORT_SYMBOL(rproc_coredump_set_elf_info);

  static void rproc_coredump_free(void *data)
  {
  	struct rproc_coredump_state *dump_state = data;
  
  	vfree(dump_state->header);
  	complete(&dump_state->dump_done);
  }
  
  static void *rproc_coredump_find_segment(loff_t user_offset,
  					 struct list_head *segments,
  					 size_t *data_left)
  {
  	struct rproc_dump_segment *segment;
  
  	list_for_each_entry(segment, segments, node) {
  		if (user_offset < segment->size) {
  			*data_left = segment->size - user_offset;
  			return segment;
  		}
  		user_offset -= segment->size;
  	}
  
  	*data_left = 0;
  	return NULL;
  }
  
  static void rproc_copy_segment(struct rproc *rproc, void *dest,
  			       struct rproc_dump_segment *segment,
  			       size_t offset, size_t size)
  {
  	void *ptr;
  
  	if (segment->dump) {
  		segment->dump(rproc, segment, dest, offset, size);
  	} else {
  		ptr = rproc_da_to_va(rproc, segment->da + offset, size);
  		if (!ptr) {
  			dev_err(&rproc->dev,
  				"invalid copy request for segment %pad with offset %zu and size %zu)
  ",
  				&segment->da, offset, size);
  			memset(dest, 0xff, size);
  		} else {
  			memcpy(dest, ptr, size);
  		}
  	}
  }
  
  static ssize_t rproc_coredump_read(char *buffer, loff_t offset, size_t count,
  				   void *data, size_t header_sz)
  {
  	size_t seg_data, bytes_left = count;
  	ssize_t copy_sz;
  	struct rproc_dump_segment *seg;
  	struct rproc_coredump_state *dump_state = data;
  	struct rproc *rproc = dump_state->rproc;
  	void *elfcore = dump_state->header;
  
  	/* Copy the vmalloc'ed header first. */
  	if (offset < header_sz) {
  		copy_sz = memory_read_from_buffer(buffer, count, &offset,
  						  elfcore, header_sz);
  
  		return copy_sz;
  	}
  
  	/*
  	 * Find out the segment memory chunk to be copied based on offset.
  	 * Keep copying data until count bytes are read.
  	 */
  	while (bytes_left) {
  		seg = rproc_coredump_find_segment(offset - header_sz,
  						  &rproc->dump_segments,
  						  &seg_data);
  		/* EOF check */
  		if (!seg) {
  			dev_info(&rproc->dev, "Ramdump done, %lld bytes read",
  				 offset);
  			break;
  		}
  
  		copy_sz = min_t(size_t, bytes_left, seg_data);
  
  		rproc_copy_segment(rproc, buffer, seg, seg->size - seg_data,
  				   copy_sz);
  
  		offset += copy_sz;
  		buffer += copy_sz;
  		bytes_left -= copy_sz;
  	}
  
  	return count - bytes_left;
  }

  /**
   * rproc_coredump() - perform coredump
   * @rproc:	rproc handle
   *
   * This function will generate an ELF header for the registered segments

   * and create a devcoredump device associated with rproc. Based on the
   * coredump configuration this function will directly copy the segments
   * from device memory to userspace or copy segments from device memory to
   * a separate buffer, which can then be read by userspace.
   * The first approach avoids using extra vmalloc memory. But it will stall
   * recovery flow until dump is read by userspace.

   */
  void rproc_coredump(struct rproc *rproc)
  {
  	struct rproc_dump_segment *segment;
  	void *phdr;
  	void *ehdr;
  	size_t data_size;
  	size_t offset;
  	void *data;

  	u8 class = rproc->elf_class;
  	int phnum = 0;

  	struct rproc_coredump_state dump_state;
  	enum rproc_dump_mechanism dump_conf = rproc->dump_conf;

  	if (list_empty(&rproc->dump_segments) ||
  	    dump_conf == RPROC_COREDUMP_DISABLED)

  		return;
  
  	if (class == ELFCLASSNONE) {
  		dev_err(&rproc->dev, "Elf class is not set
  ");
  		return;
  	}
  
  	data_size = elf_size_of_hdr(class);
  	list_for_each_entry(segment, &rproc->dump_segments, node) {

  		/*
  		 * For default configuration buffer includes headers & segments.
  		 * For inline dump buffer just includes headers as segments are
  		 * directly read from device memory.
  		 */
  		data_size += elf_size_of_phdr(class);

  		if (dump_conf == RPROC_COREDUMP_ENABLED)

  			data_size += segment->size;

  
  		phnum++;
  	}
  
  	data = vmalloc(data_size);
  	if (!data)
  		return;
  
  	ehdr = data;
  
  	memset(ehdr, 0, elf_size_of_hdr(class));
  	/* e_ident field is common for both elf32 and elf64 */
  	elf_hdr_init_ident(ehdr, class);
  
  	elf_hdr_set_e_type(class, ehdr, ET_CORE);
  	elf_hdr_set_e_machine(class, ehdr, rproc->elf_machine);
  	elf_hdr_set_e_version(class, ehdr, EV_CURRENT);
  	elf_hdr_set_e_entry(class, ehdr, rproc->bootaddr);
  	elf_hdr_set_e_phoff(class, ehdr, elf_size_of_hdr(class));
  	elf_hdr_set_e_ehsize(class, ehdr, elf_size_of_hdr(class));
  	elf_hdr_set_e_phentsize(class, ehdr, elf_size_of_phdr(class));
  	elf_hdr_set_e_phnum(class, ehdr, phnum);
  
  	phdr = data + elf_hdr_get_e_phoff(class, ehdr);
  	offset = elf_hdr_get_e_phoff(class, ehdr);
  	offset += elf_size_of_phdr(class) * elf_hdr_get_e_phnum(class, ehdr);
  
  	list_for_each_entry(segment, &rproc->dump_segments, node) {
  		memset(phdr, 0, elf_size_of_phdr(class));
  		elf_phdr_set_p_type(class, phdr, PT_LOAD);
  		elf_phdr_set_p_offset(class, phdr, offset);
  		elf_phdr_set_p_vaddr(class, phdr, segment->da);
  		elf_phdr_set_p_paddr(class, phdr, segment->da);
  		elf_phdr_set_p_filesz(class, phdr, segment->size);
  		elf_phdr_set_p_memsz(class, phdr, segment->size);
  		elf_phdr_set_p_flags(class, phdr, PF_R | PF_W | PF_X);
  		elf_phdr_set_p_align(class, phdr, 0);

  		if (dump_conf == RPROC_COREDUMP_ENABLED)

  			rproc_copy_segment(rproc, data + offset, segment, 0,
  					   segment->size);

  
  		offset += elf_phdr_get_p_filesz(class, phdr);
  		phdr += elf_size_of_phdr(class);
  	}

  	if (dump_conf == RPROC_COREDUMP_ENABLED) {

  		dev_coredumpv(&rproc->dev, data, data_size, GFP_KERNEL);
  		return;
  	}
  
  	/* Initialize the dump state struct to be used by rproc_coredump_read */
  	dump_state.rproc = rproc;
  	dump_state.header = data;
  	init_completion(&dump_state.dump_done);
  
  	dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, GFP_KERNEL,
  		      rproc_coredump_read, rproc_coredump_free);

  	/*
  	 * Wait until the dump is read and free is called. Data is freed
  	 * by devcoredump framework automatically after 5 minutes.
  	 */
  	wait_for_completion(&dump_state.dump_done);

  }