Commit d26c3321 authored by WeiXiong Liao's avatar WeiXiong Liao Committed by Kees Cook
Browse files

pstore/zone: Introduce common layer to manage storage zones 



Implement a common set of APIs needed to support pstore storage zones,
based on how ramoops is designed. This will be used by pstore/blk with
the intention of migrating pstore/ram in the future.

Signed-off-by: default avatarWeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/lkml/20200511233229.27745-2-keescook@chromium.org/


Co-developed-by: default avatarKees Cook <keescook@chromium.org>
Signed-off-by: default avatarKees Cook <keescook@chromium.org>
parent acf12c5e

fs/pstore/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -153,3 +153,10 @@ config PSTORE_RAM 
	  "ramoops.ko".



	  For more information, see Documentation/admin-guide/ramoops.rst.



config PSTORE_ZONE

	tristate

	depends on PSTORE

	help

	  The common layer for pstore/blk (and pstore/ram in the future)

	  to manage storage in zones.

fs/pstore/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -12,3 +12,6 @@ pstore-$(CONFIG_PSTORE_PMSG) += pmsg.o 


ramoops-objs += ram.o ram_core.o

obj-$(CONFIG_PSTORE_RAM)	+= ramoops.o



pstore_zone-objs += zone.o

obj-$(CONFIG_PSTORE_ZONE)	+= pstore_zone.o

fs/pstore/zone.c

0 → 100644
+985 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Provide a pstore intermediate backend, organized into kernel memory

 * allocated zones that are then mapped and flushed into a single

 * contiguous region on a storage backend of some kind (block, mtd, etc).

 */



#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/mount.h>

#include <linux/printk.h>

#include <linux/fs.h>

#include <linux/pstore_zone.h>

#include <linux/kdev_t.h>

#include <linux/device.h>

#include <linux/namei.h>

#include <linux/fcntl.h>

#include <linux/uio.h>

#include <linux/writeback.h>

#include "internal.h"



/**

 * struct psz_head - header of zone to flush to storage

 *

 * @sig: signature to indicate header (PSZ_SIG xor PSZONE-type value)

 * @datalen: length of data in @data

 * @data: zone data.

 */

struct psz_buffer {

#define PSZ_SIG (0x43474244) /* DBGC */

	uint32_t sig;

	atomic_t datalen;

	uint8_t data[];

};



/**

 * struct psz_kmsg_header - kmsg dump-specific header to flush to storage

 *

 * @magic: magic num for kmsg dump header

 * @time: kmsg dump trigger time

 * @compressed: whether conpressed

 * @counter: kmsg dump counter

 * @reason: the kmsg dump reason (e.g. oops, panic, etc)

 * @data: pointer to log data

 *

 * This is a sub-header for a kmsg dump, trailing after &psz_buffer.

 */

struct psz_kmsg_header {

#define PSTORE_KMSG_HEADER_MAGIC 0x4dfc3ae5 /* Just a random number */

	uint32_t magic;

	struct timespec64 time;

	bool compressed;

	uint32_t counter;

	enum kmsg_dump_reason reason;

	uint8_t data[];

};



/**

 * struct pstore_zone - single stored buffer

 *

 * @off: zone offset of storage

 * @type: front-end type for this zone

 * @name: front-end name for this zone

 * @buffer: pointer to data buffer managed by this zone

 * @oldbuf: pointer to old data buffer

 * @buffer_size: bytes in @buffer->data

 * @should_recover: whether this zone should recover from storage

 * @dirty: whether the data in @buffer dirty

 *

 * zone structure in memory.

 */

struct pstore_zone {

	loff_t off;

	const char *name;

	enum pstore_type_id type;



	struct psz_buffer *buffer;

	struct psz_buffer *oldbuf;

	size_t buffer_size;

	bool should_recover;

	atomic_t dirty;

};



/**

 * struct psz_context - all about running state of pstore/zone

 *

 * @kpszs: kmsg dump storage zones

 * @kmsg_max_cnt: max count of @kpszs

 * @kmsg_read_cnt: counter of total read kmsg dumps

 * @kmsg_write_cnt: counter of total kmsg dump writes

 * @oops_counter: counter of oops dumps

 * @panic_counter: counter of panic dumps

 * @recovered: whether finished recovering data from storage

 * @on_panic: whether panic is happening

 * @pstore_zone_info_lock: lock to @pstore_zone_info

 * @pstore_zone_info: information from backend

 * @pstore: structure for pstore

 */

struct psz_context {

	struct pstore_zone **kpszs;

	unsigned int kmsg_max_cnt;

	unsigned int kmsg_read_cnt;

	unsigned int kmsg_write_cnt;

	/*

	 * These counters should be calculated during recovery.

	 * It records the oops/panic times after crashes rather than boots.

	 */

	unsigned int oops_counter;

	unsigned int panic_counter;

	atomic_t recovered;

	atomic_t on_panic;



	/*

	 * pstore_zone_info_lock protects this entire structure during calls

	 * to register_pstore_zone()/unregister_pstore_zone().

	 */

	struct mutex pstore_zone_info_lock;

	struct pstore_zone_info *pstore_zone_info;

	struct pstore_info pstore;

};

static struct psz_context pstore_zone_cxt;



/**

 * enum psz_flush_mode - flush mode for psz_zone_write()

 *

 * @FLUSH_NONE: do not flush to storage but update data on memory

 * @FLUSH_PART: just flush part of data including meta data to storage

 * @FLUSH_META: just flush meta data of zone to storage

 * @FLUSH_ALL: flush all of zone

 */

enum psz_flush_mode {

	FLUSH_NONE = 0,

	FLUSH_PART,

	FLUSH_META,

	FLUSH_ALL,

};



static inline int buffer_datalen(struct pstore_zone *zone)

{

	return atomic_read(&zone->buffer->datalen);

}



static inline bool is_on_panic(void)

{

	return atomic_read(&pstore_zone_cxt.on_panic);

}



static ssize_t psz_zone_read(struct pstore_zone *zone, char *buf,

		size_t len, unsigned long off)

{

	if (!buf || !zone->buffer)

		return -EINVAL;

	if (off > zone->buffer_size)

		return -EINVAL;

	len = min_t(size_t, len, zone->buffer_size - off);

	memcpy(buf, zone->buffer->data + off, len);

	return len;

}



static int psz_zone_write(struct pstore_zone *zone,

		enum psz_flush_mode flush_mode, const char *buf,

		size_t len, unsigned long off)

{

	struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;

	ssize_t wcnt = 0;

	ssize_t (*writeop)(const char *buf, size_t bytes, loff_t pos);

	size_t wlen;



	if (off > zone->buffer_size)

		return -EINVAL;



	wlen = min_t(size_t, len, zone->buffer_size - off);

	if (buf && wlen) {

		memcpy(zone->buffer->data + off, buf, wlen);

		atomic_set(&zone->buffer->datalen, wlen + off);

	}



	/* avoid to damage old records */

	if (!is_on_panic() && !atomic_read(&pstore_zone_cxt.recovered))

		goto dirty;



	writeop = is_on_panic() ? info->panic_write : info->write;

	if (!writeop)

		goto dirty;



	switch (flush_mode) {

	case FLUSH_NONE:

		if (unlikely(buf && wlen))

			goto dirty;

		return 0;

	case FLUSH_PART:

		wcnt = writeop((const char *)zone->buffer->data + off, wlen,

				zone->off + sizeof(*zone->buffer) + off);

		if (wcnt != wlen)

			goto dirty;

		fallthrough;

	case FLUSH_META:

		wlen = sizeof(struct psz_buffer);

		wcnt = writeop((const char *)zone->buffer, wlen, zone->off);

		if (wcnt != wlen)

			goto dirty;

		break;

	case FLUSH_ALL:

		wlen = zone->buffer_size + sizeof(*zone->buffer);

		wcnt = writeop((const char *)zone->buffer, wlen, zone->off);

		if (wcnt != wlen)

			goto dirty;

		break;

	}



	return 0;

dirty:

	atomic_set(&zone->dirty, true);

	return -EBUSY;

}



static int psz_flush_dirty_zone(struct pstore_zone *zone)

{

	int ret;



	if (unlikely(!zone))

		return -EINVAL;



	if (unlikely(!atomic_read(&pstore_zone_cxt.recovered)))

		return -EBUSY;



	if (!atomic_xchg(&zone->dirty, false))

		return 0;



	ret = psz_zone_write(zone, FLUSH_ALL, NULL, 0, 0);

	if (ret)

		atomic_set(&zone->dirty, true);

	return ret;

}



static int psz_flush_dirty_zones(struct pstore_zone **zones, unsigned int cnt)

{

	int i, ret;

	struct pstore_zone *zone;



	if (!zones)

		return -EINVAL;



	for (i = 0; i < cnt; i++) {

		zone = zones[i];

		if (!zone)

			return -EINVAL;

		ret = psz_flush_dirty_zone(zone);

		if (ret)

			return ret;

	}

	return 0;

}



static int psz_move_zone(struct pstore_zone *old, struct pstore_zone *new)

{

	const char *data = (const char *)old->buffer->data;

	int ret;



	ret = psz_zone_write(new, FLUSH_ALL, data, buffer_datalen(old), 0);

	if (ret) {

		atomic_set(&new->buffer->datalen, 0);

		atomic_set(&new->dirty, false);

		return ret;

	}

	atomic_set(&old->buffer->datalen, 0);

	return 0;

}



static int psz_kmsg_recover_data(struct psz_context *cxt)

{

	struct pstore_zone_info *info = cxt->pstore_zone_info;

	struct pstore_zone *zone = NULL;

	struct psz_buffer *buf;

	unsigned long i;

	ssize_t rcnt;



	if (!info->read)

		return -EINVAL;



	for (i = 0; i < cxt->kmsg_max_cnt; i++) {

		zone = cxt->kpszs[i];

		if (unlikely(!zone))

			return -EINVAL;

		if (atomic_read(&zone->dirty)) {

			unsigned int wcnt = cxt->kmsg_write_cnt;

			struct pstore_zone *new = cxt->kpszs[wcnt];

			int ret;



			ret = psz_move_zone(zone, new);

			if (ret) {

				pr_err("move zone from %lu to %d failed\n",

						i, wcnt);

				return ret;

			}

			cxt->kmsg_write_cnt = (wcnt + 1) % cxt->kmsg_max_cnt;

		}

		if (!zone->should_recover)

			continue;

		buf = zone->buffer;

		rcnt = info->read((char *)buf, zone->buffer_size + sizeof(*buf),

				zone->off);

		if (rcnt != zone->buffer_size + sizeof(*buf))

			return (int)rcnt < 0 ? (int)rcnt : -EIO;

	}

	return 0;

}



static int psz_kmsg_recover_meta(struct psz_context *cxt)

{

	struct pstore_zone_info *info = cxt->pstore_zone_info;

	struct pstore_zone *zone;

	size_t rcnt, len;

	struct psz_buffer *buf;

	struct psz_kmsg_header *hdr;

	struct timespec64 time = { };

	unsigned long i;

	/*

	 * Recover may on panic, we can't allocate any memory by kmalloc.

	 * So, we use local array instead.

	 */

	char buffer_header[sizeof(*buf) + sizeof(*hdr)] = {0};



	if (!info->read)

		return -EINVAL;



	len = sizeof(*buf) + sizeof(*hdr);

	buf = (struct psz_buffer *)buffer_header;

	for (i = 0; i < cxt->kmsg_max_cnt; i++) {

		zone = cxt->kpszs[i];

		if (unlikely(!zone))

			return -EINVAL;



		rcnt = info->read((char *)buf, len, zone->off);

		if (rcnt != len) {

			pr_err("read %s with id %lu failed\n", zone->name, i);

			return (int)rcnt < 0 ? (int)rcnt : -EIO;

		}



		if (buf->sig != zone->buffer->sig) {

			pr_debug("no valid data in kmsg dump zone %lu\n", i);

			continue;

		}



		if (zone->buffer_size < atomic_read(&buf->datalen)) {

			pr_info("found overtop zone: %s: id %lu, off %lld, size %zu\n",

					zone->name, i, zone->off,

					zone->buffer_size);

			continue;

		}



		hdr = (struct psz_kmsg_header *)buf->data;

		if (hdr->magic != PSTORE_KMSG_HEADER_MAGIC) {

			pr_info("found invalid zone: %s: id %lu, off %lld, size %zu\n",

					zone->name, i, zone->off,

					zone->buffer_size);

			continue;

		}



		/*

		 * we get the newest zone, and the next one must be the oldest

		 * or unused zone, because we do write one by one like a circle.

		 */

		if (hdr->time.tv_sec >= time.tv_sec) {

			time.tv_sec = hdr->time.tv_sec;

			cxt->kmsg_write_cnt = (i + 1) % cxt->kmsg_max_cnt;

		}



		if (hdr->reason == KMSG_DUMP_OOPS)

			cxt->oops_counter =

				max(cxt->oops_counter, hdr->counter);

		else if (hdr->reason == KMSG_DUMP_PANIC)

			cxt->panic_counter =

				max(cxt->panic_counter, hdr->counter);



		if (!atomic_read(&buf->datalen)) {

			pr_debug("found erased zone: %s: id %lu, off %lld, size %zu, datalen %d\n",

					zone->name, i, zone->off,

					zone->buffer_size,

					atomic_read(&buf->datalen));

			continue;

		}



		if (!is_on_panic())

			zone->should_recover = true;

		pr_debug("found nice zone: %s: id %lu, off %lld, size %zu, datalen %d\n",

				zone->name, i, zone->off,

				zone->buffer_size, atomic_read(&buf->datalen));

	}



	return 0;

}



static int psz_kmsg_recover(struct psz_context *cxt)

{

	int ret;



	if (!cxt->kpszs)

		return 0;



	ret = psz_kmsg_recover_meta(cxt);

	if (ret)

		goto recover_fail;



	ret = psz_kmsg_recover_data(cxt);

	if (ret)

		goto recover_fail;



	return 0;

recover_fail:

	pr_debug("psz_recover_kmsg failed\n");

	return ret;

}



/**

 * psz_recovery() - recover data from storage

 * @cxt: the context of pstore/zone

 *

 * recovery means reading data back from storage after rebooting

 *

 * Return: 0 on success, others on failure.

 */

static inline int psz_recovery(struct psz_context *cxt)

{

	int ret;



	if (atomic_read(&cxt->recovered))

		return 0;



	ret = psz_kmsg_recover(cxt);



	if (unlikely(ret))

		pr_err("recover failed\n");

	else {

		pr_debug("recover end!\n");

		atomic_set(&cxt->recovered, 1);

	}

	return ret;

}



static int psz_pstore_open(struct pstore_info *psi)

{

	struct psz_context *cxt = psi->data;



	cxt->kmsg_read_cnt = 0;

	return 0;

}



static inline bool psz_ok(struct pstore_zone *zone)

{

	if (zone && zone->buffer && buffer_datalen(zone))

		return true;

	return false;

}



static inline int psz_kmsg_erase(struct psz_context *cxt,

		struct pstore_zone *zone, struct pstore_record *record)

{

	struct psz_buffer *buffer = zone->buffer;

	struct psz_kmsg_header *hdr =

		(struct psz_kmsg_header *)buffer->data;



	if (unlikely(!psz_ok(zone)))

		return 0;

	/* this zone is already updated, no need to erase */

	if (record->count != hdr->counter)

		return 0;



	atomic_set(&zone->buffer->datalen, 0);

	return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);

}



static int psz_pstore_erase(struct pstore_record *record)

{

	struct psz_context *cxt = record->psi->data;



	switch (record->type) {

	case PSTORE_TYPE_DMESG:

		if (record->id >= cxt->kmsg_max_cnt)

			return -EINVAL;

		return psz_kmsg_erase(cxt, cxt->kpszs[record->id], record);

	default:

		return -EINVAL;

	}

}



static void psz_write_kmsg_hdr(struct pstore_zone *zone,

		struct pstore_record *record)

{

	struct psz_context *cxt = record->psi->data;

	struct psz_buffer *buffer = zone->buffer;

	struct psz_kmsg_header *hdr =

		(struct psz_kmsg_header *)buffer->data;



	hdr->magic = PSTORE_KMSG_HEADER_MAGIC;

	hdr->compressed = record->compressed;

	hdr->time.tv_sec = record->time.tv_sec;

	hdr->time.tv_nsec = record->time.tv_nsec;

	hdr->reason = record->reason;

	if (hdr->reason == KMSG_DUMP_OOPS)

		hdr->counter = ++cxt->oops_counter;

	else if (hdr->reason == KMSG_DUMP_PANIC)

		hdr->counter = ++cxt->panic_counter;

	else

		hdr->counter = 0;

}



static inline int notrace psz_kmsg_write_record(struct psz_context *cxt,

		struct pstore_record *record)

{

	size_t size, hlen;

	struct pstore_zone *zone;

	unsigned int zonenum;



	zonenum = cxt->kmsg_write_cnt;

	zone = cxt->kpszs[zonenum];

	if (unlikely(!zone))

		return -ENOSPC;

	cxt->kmsg_write_cnt = (zonenum + 1) % cxt->kmsg_max_cnt;



	pr_debug("write %s to zone id %d\n", zone->name, zonenum);

	psz_write_kmsg_hdr(zone, record);

	hlen = sizeof(struct psz_kmsg_header);

	size = min_t(size_t, record->size, zone->buffer_size - hlen);

	return psz_zone_write(zone, FLUSH_ALL, record->buf, size, hlen);

}



static int notrace psz_kmsg_write(struct psz_context *cxt,

		struct pstore_record *record)

{

	int ret;



	/*

	 * Explicitly only take the first part of any new crash.

	 * If our buffer is larger than kmsg_bytes, this can never happen,

	 * and if our buffer is smaller than kmsg_bytes, we don't want the

	 * report split across multiple records.

	 */

	if (record->part != 1)

		return -ENOSPC;



	if (!cxt->kpszs)

		return -ENOSPC;



	ret = psz_kmsg_write_record(cxt, record);

	if (!ret) {

		pr_debug("try to flush other dirty zones\n");

		psz_flush_dirty_zones(cxt->kpszs, cxt->kmsg_max_cnt);

	}



	/* always return 0 as we had handled it on buffer */

	return 0;

}



static int notrace psz_pstore_write(struct pstore_record *record)

{

	struct psz_context *cxt = record->psi->data;



	if (record->type == PSTORE_TYPE_DMESG &&

			record->reason == KMSG_DUMP_PANIC)

		atomic_set(&cxt->on_panic, 1);



	switch (record->type) {

	case PSTORE_TYPE_DMESG:

		return psz_kmsg_write(cxt, record);

	default:

		return -EINVAL;

	}

}



static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt)

{

	struct pstore_zone *zone = NULL;



	while (cxt->kmsg_read_cnt < cxt->kmsg_max_cnt) {

		zone = cxt->kpszs[cxt->kmsg_read_cnt++];

		if (psz_ok(zone))

			return zone;

	}



	return NULL;

}



static int psz_kmsg_read_hdr(struct pstore_zone *zone,

		struct pstore_record *record)

{

	struct psz_buffer *buffer = zone->buffer;

	struct psz_kmsg_header *hdr =

		(struct psz_kmsg_header *)buffer->data;



	if (hdr->magic != PSTORE_KMSG_HEADER_MAGIC)

		return -EINVAL;

	record->compressed = hdr->compressed;

	record->time.tv_sec = hdr->time.tv_sec;

	record->time.tv_nsec = hdr->time.tv_nsec;

	record->reason = hdr->reason;

	record->count = hdr->counter;

	return 0;

}



static ssize_t psz_kmsg_read(struct pstore_zone *zone,

		struct pstore_record *record)

{

	ssize_t size, hlen = 0;



	size = buffer_datalen(zone);

	/* Clear and skip this kmsg dump record if it has no valid header */

	if (psz_kmsg_read_hdr(zone, record)) {

		atomic_set(&zone->buffer->datalen, 0);

		atomic_set(&zone->dirty, 0);

		return -ENOMSG;

	}

	size -= sizeof(struct psz_kmsg_header);



	if (!record->compressed) {

		char *buf = kasprintf(GFP_KERNEL, "%s: Total %d times\n",

				      kmsg_dump_reason_str(record->reason),

				      record->count);

		hlen = strlen(buf);

		record->buf = krealloc(buf, hlen + size, GFP_KERNEL);

		if (!record->buf) {

			kfree(buf);

			return -ENOMEM;

		}

	} else {

		record->buf = kmalloc(size, GFP_KERNEL);

		if (!record->buf)

			return -ENOMEM;

	}



	size = psz_zone_read(zone, record->buf + hlen, size,

			sizeof(struct psz_kmsg_header));

	if (unlikely(size < 0)) {

		kfree(record->buf);

		return -ENOMSG;

	}



	return size + hlen;

}



static ssize_t psz_pstore_read(struct pstore_record *record)

{

	struct psz_context *cxt = record->psi->data;

	ssize_t (*readop)(struct pstore_zone *zone,

			struct pstore_record *record);

	struct pstore_zone *zone;

	ssize_t ret;



	/* before read, we must recover from storage */

	ret = psz_recovery(cxt);

	if (ret)

		return ret;



next_zone:

	zone = psz_read_next_zone(cxt);

	if (!zone)

		return 0;



	record->type = zone->type;

	switch (record->type) {

	case PSTORE_TYPE_DMESG:

		readop = psz_kmsg_read;

		record->id = cxt->kmsg_read_cnt - 1;

		break;

	default:

		goto next_zone;

	}



	ret = readop(zone, record);

	if (ret == -ENOMSG)

		goto next_zone;

	return ret;

}



static struct psz_context pstore_zone_cxt = {

	.pstore_zone_info_lock =

		__MUTEX_INITIALIZER(pstore_zone_cxt.pstore_zone_info_lock),

	.recovered = ATOMIC_INIT(0),

	.on_panic = ATOMIC_INIT(0),

	.pstore = {

		.owner = THIS_MODULE,

		.open = psz_pstore_open,

		.read = psz_pstore_read,

		.write = psz_pstore_write,

		.erase = psz_pstore_erase,

	},

};



static void psz_free_zone(struct pstore_zone **pszone)

{

	struct pstore_zone *zone = *pszone;



	if (!zone)

		return;



	kfree(zone->buffer);

	kfree(zone);

	*pszone = NULL;

}



static void psz_free_zones(struct pstore_zone ***pszones, unsigned int *cnt)

{

	struct pstore_zone **zones = *pszones;



	if (!zones)

		return;



	while (*cnt > 0) {

		(*cnt)--;

		psz_free_zone(&(zones[*cnt]));

	}

	kfree(zones);

	*pszones = NULL;

}



static void psz_free_all_zones(struct psz_context *cxt)

{

	if (cxt->kpszs)

		psz_free_zones(&cxt->kpszs, &cxt->kmsg_max_cnt);

}



static struct pstore_zone *psz_init_zone(enum pstore_type_id type,

		loff_t *off, size_t size)

{

	struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;

	struct pstore_zone *zone;

	const char *name = pstore_type_to_name(type);



	if (!size)

		return NULL;



	if (*off + size > info->total_size) {

		pr_err("no room for %s (0x%zx@0x%llx over 0x%lx)\n",

			name, size, *off, info->total_size);

		return ERR_PTR(-ENOMEM);

	}



	zone = kzalloc(sizeof(struct pstore_zone), GFP_KERNEL);

	if (!zone)

		return ERR_PTR(-ENOMEM);



	zone->buffer = kmalloc(size, GFP_KERNEL);

	if (!zone->buffer) {

		kfree(zone);

		return ERR_PTR(-ENOMEM);

	}

	memset(zone->buffer, 0xFF, size);

	zone->off = *off;

	zone->name = name;

	zone->type = type;

	zone->buffer_size = size - sizeof(struct psz_buffer);

	zone->buffer->sig = type ^ PSZ_SIG;

	atomic_set(&zone->dirty, 0);

	atomic_set(&zone->buffer->datalen, 0);



	*off += size;



	pr_debug("pszone %s: off 0x%llx, %zu header, %zu data\n", zone->name,

			zone->off, sizeof(*zone->buffer), zone->buffer_size);

	return zone;

}



static struct pstore_zone **psz_init_zones(enum pstore_type_id type,

	loff_t *off, size_t total_size, ssize_t record_size,

	unsigned int *cnt)

{

	struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;

	struct pstore_zone **zones, *zone;

	const char *name = pstore_type_to_name(type);

	int c, i;



	*cnt = 0;

	if (!total_size || !record_size)

		return NULL;



	if (*off + total_size > info->total_size) {

		pr_err("no room for zones %s (0x%zx@0x%llx over 0x%lx)\n",

			name, total_size, *off, info->total_size);

		return ERR_PTR(-ENOMEM);

	}



	c = total_size / record_size;

	zones = kcalloc(c, sizeof(*zones), GFP_KERNEL);

	if (!zones) {

		pr_err("allocate for zones %s failed\n", name);

		return ERR_PTR(-ENOMEM);

	}

	memset(zones, 0, c * sizeof(*zones));



	for (i = 0; i < c; i++) {

		zone = psz_init_zone(type, off, record_size);

		if (!zone || IS_ERR(zone)) {

			pr_err("initialize zones %s failed\n", name);

			psz_free_zones(&zones, &i);

			return (void *)zone;

		}

		zones[i] = zone;

	}



	*cnt = c;

	return zones;

}



static int psz_alloc_zones(struct psz_context *cxt)

{

	struct pstore_zone_info *info = cxt->pstore_zone_info;

	loff_t off = 0;

	int err;

	size_t size;



	size = info->total_size;

	cxt->kpszs = psz_init_zones(PSTORE_TYPE_DMESG, &off, size,

			info->kmsg_size, &cxt->kmsg_max_cnt);

	if (IS_ERR(cxt->kpszs)) {

		err = PTR_ERR(cxt->kpszs);

		cxt->kpszs = NULL;

		goto fail_out;

	}



	return 0;

fail_out:

	return err;

}



/**

 * register_pstore_zone() - register to pstore/zone

 *

 * @info: back-end driver information. See &struct pstore_zone_info.

 *

 * Only one back-end at one time.

 *

 * Return: 0 on success, others on failure.

 */

int register_pstore_zone(struct pstore_zone_info *info)

{

	int err = -EINVAL;

	struct psz_context *cxt = &pstore_zone_cxt;



	if (info->total_size < 4096) {

		pr_warn("total_size must be >= 4096\n");

		return -EINVAL;

	}



	if (!info->kmsg_size) {

		pr_warn("at least one record size must be non-zero\n");

		return -EINVAL;

	}



	if (!info->name || !info->name[0])

		return -EINVAL;



#define check_size(name, size) {					\

		if (info->name > 0 && info->name < (size)) {		\

			pr_err(#name " must be over %d\n", (size));	\

			return -EINVAL;					\

		}							\

		if (info->name & (size - 1)) {				\

			pr_err(#name " must be a multiple of %d\n",	\

					(size));			\

			return -EINVAL;					\

		}							\

	}



	check_size(total_size, 4096);

	check_size(kmsg_size, SECTOR_SIZE);



#undef check_size



	/*

	 * the @read and @write must be applied.

	 * if no @read, pstore may mount failed.

	 * if no @write, pstore do not support to remove record file.

	 */

	if (!info->read || !info->write) {

		pr_err("no valid general read/write interface\n");

		return -EINVAL;

	}



	mutex_lock(&cxt->pstore_zone_info_lock);

	if (cxt->pstore_zone_info) {

		pr_warn("'%s' already loaded: ignoring '%s'\n",

				cxt->pstore_zone_info->name, info->name);

		mutex_unlock(&cxt->pstore_zone_info_lock);

		return -EBUSY;

	}

	cxt->pstore_zone_info = info;



	pr_debug("register %s with properties:\n", info->name);

	pr_debug("\ttotal size : %ld Bytes\n", info->total_size);

	pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);



	err = psz_alloc_zones(cxt);

	if (err) {

		pr_err("alloc zones failed\n");

		goto fail_out;

	}



	if (info->kmsg_size) {

		cxt->pstore.bufsize = cxt->kpszs[0]->buffer_size -

			sizeof(struct psz_kmsg_header);

		cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL);

		if (!cxt->pstore.buf) {

			err = -ENOMEM;

			goto fail_free;

		}

	}

	cxt->pstore.data = cxt;



	pr_info("registered %s as backend for", info->name);

	cxt->pstore.max_reason = info->max_reason;

	cxt->pstore.name = info->name;

	if (info->kmsg_size) {

		cxt->pstore.flags |= PSTORE_FLAGS_DMESG;

		pr_cont(" kmsg(%s",

			kmsg_dump_reason_str(cxt->pstore.max_reason));

		if (cxt->pstore_zone_info->panic_write)

			pr_cont(",panic_write");

		pr_cont(")");

	}

	pr_cont("\n");



	err = pstore_register(&cxt->pstore);

	if (err) {

		pr_err("registering with pstore failed\n");

		goto fail_free;

	}

	mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);



	return 0;



fail_free:

	kfree(cxt->pstore.buf);

	cxt->pstore.buf = NULL;

	cxt->pstore.bufsize = 0;

	psz_free_all_zones(cxt);

fail_out:

	pstore_zone_cxt.pstore_zone_info = NULL;

	mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);

	return err;

}

EXPORT_SYMBOL_GPL(register_pstore_zone);



/**

 * unregister_pstore_zone() - unregister to pstore/zone

 *

 * @info: back-end driver information. See struct pstore_zone_info.

 */

void unregister_pstore_zone(struct pstore_zone_info *info)

{

	struct psz_context *cxt = &pstore_zone_cxt;



	mutex_lock(&cxt->pstore_zone_info_lock);

	if (!cxt->pstore_zone_info) {

		mutex_unlock(&cxt->pstore_zone_info_lock);

		return;

	}



	/* Stop incoming writes from pstore. */

	pstore_unregister(&cxt->pstore);



	/* Clean up allocations. */

	kfree(cxt->pstore.buf);

	cxt->pstore.buf = NULL;

	cxt->pstore.bufsize = 0;

	cxt->pstore_zone_info = NULL;



	psz_free_all_zones(cxt);



	/* Clear counters and zone state. */

	cxt->oops_counter = 0;

	cxt->panic_counter = 0;

	atomic_set(&cxt->recovered, 0);

	atomic_set(&cxt->on_panic, 0);



	mutex_unlock(&cxt->pstore_zone_info_lock);

}

EXPORT_SYMBOL_GPL(unregister_pstore_zone);



MODULE_LICENSE("GPL");

MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");

MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");

MODULE_DESCRIPTION("Storage Manager for pstore/blk");

CRA Git | Maintained and supported by SUSTech CRA and CCSE