Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2575be8a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'pstore-v4.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux 

Pull pstore updates from Kees Cook:
 "This has a large internal refactoring along with several smaller
  fixes.

   - constify compression structures; Bhumika Goyal

   - restore powerpc dumping; Ankit Kumar

   - fix more bugs in the rarely exercises module unloading logic

   - reorganize filesystem locking to fix problems noticed by lockdep

   - refactor internal pstore APIs to make development and review
     easier:
      - improve error reporting
      - add kernel-doc structure and function comments
      - avoid insane argument passing by using a common record
        structure"

* tag 'pstore-v4.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux: (23 commits)
  pstore: Solve lockdep warning by moving inode locks
  pstore: Fix flags to enable dumps on powerpc
  pstore: Remove unused vmalloc.h in pmsg
  pstore: simplify write_user_compat()
  pstore: Remove write_buf() callback
  pstore: Replace arguments for write_buf_user() API
  pstore: Replace arguments for write_buf() API
  pstore: Replace arguments for erase() API
  pstore: Do not duplicate record metadata
  pstore: Allocate records on heap instead of stack
  pstore: Pass record contents instead of copying
  pstore: Always allocate buffer for decompression
  pstore: Replace arguments for write() API
  pstore: Replace arguments for read() API
  pstore: Switch pstore_mkfile to pass record
  pstore: Move record decompression to function
  pstore: Extract common arguments into structure
  pstore: Add kernel-doc for struct pstore_info
  pstore: Improve register_pstore() error reporting
  pstore: Avoid race in module unloading
  ...
parents c58d4055 3a7d2fd1

arch/powerpc/kernel/nvram_64.c

+38 −51
Original line number Diff line number Diff line
@@ -389,51 +389,40 @@ static int nvram_pstore_open(struct pstore_info *psi) 


/**

 * nvram_pstore_write - pstore write callback for nvram

 * @type:               Type of message logged

 * @reason:             reason behind dump (oops/panic)

 * @id:                 identifier to indicate the write performed

 * @part:               pstore writes data to registered buffer in parts,

 *                      part number will indicate the same.

 * @count:              Indicates oops count

 * @compressed:         Flag to indicate the log is compressed

 * @size:               number of bytes written to the registered buffer

 * @psi:                registered pstore_info structure

 * @record:             pstore record to write, with @id to be set

 *

 * Called by pstore_dump() when an oops or panic report is logged in the

 * printk buffer.

 * Returns 0 on successful write.

 */

static int nvram_pstore_write(enum pstore_type_id type,

				enum kmsg_dump_reason reason,

				u64 *id, unsigned int part, int count,

				bool compressed, size_t size,

				struct pstore_info *psi)

static int nvram_pstore_write(struct pstore_record *record)

{

	int rc;

	unsigned int err_type = ERR_TYPE_KERNEL_PANIC;

	struct oops_log_info *oops_hdr = (struct oops_log_info *) oops_buf;



	/* part 1 has the recent messages from printk buffer */

	if (part > 1 || (type != PSTORE_TYPE_DMESG))

	if (record->part > 1 || (record->type != PSTORE_TYPE_DMESG))

		return -1;



	if (clobbering_unread_rtas_event())

		return -1;



	oops_hdr->version = cpu_to_be16(OOPS_HDR_VERSION);

	oops_hdr->report_length = cpu_to_be16(size);

	oops_hdr->report_length = cpu_to_be16(record->size);

	oops_hdr->timestamp = cpu_to_be64(ktime_get_real_seconds());



	if (compressed)

	if (record->compressed)

		err_type = ERR_TYPE_KERNEL_PANIC_GZ;



	rc = nvram_write_os_partition(&oops_log_partition, oops_buf,

		(int) (sizeof(*oops_hdr) + size), err_type, count);

		(int) (sizeof(*oops_hdr) + record->size), err_type,

		record->count);



	if (rc != 0)

		return rc;



	*id = part;

	record->id = record->part;

	return 0;

}
@@ -442,10 +431,7 @@ static int nvram_pstore_write(enum pstore_type_id type, 
 * Returns the length of the data we read from each partition.

 * Returns 0 if we've been called before.

 */

static ssize_t nvram_pstore_read(u64 *id, enum pstore_type_id *type,

				int *count, struct timespec *time, char **buf,

				bool *compressed, ssize_t *ecc_notice_size,

				struct pstore_info *psi)

static ssize_t nvram_pstore_read(struct pstore_record *record)

{

	struct oops_log_info *oops_hdr;

	unsigned int err_type, id_no, size = 0;
@@ -459,40 +445,40 @@ static ssize_t nvram_pstore_read(u64 *id, enum pstore_type_id *type, 
	switch (nvram_type_ids[read_type]) {

	case PSTORE_TYPE_DMESG:

		part = &oops_log_partition;

		*type = PSTORE_TYPE_DMESG;

		record->type = PSTORE_TYPE_DMESG;

		break;

	case PSTORE_TYPE_PPC_COMMON:

		sig = NVRAM_SIG_SYS;

		part = &common_partition;

		*type = PSTORE_TYPE_PPC_COMMON;

		*id = PSTORE_TYPE_PPC_COMMON;

		time->tv_sec = 0;

		time->tv_nsec = 0;

		record->type = PSTORE_TYPE_PPC_COMMON;

		record->id = PSTORE_TYPE_PPC_COMMON;

		record->time.tv_sec = 0;

		record->time.tv_nsec = 0;

		break;

#ifdef CONFIG_PPC_PSERIES

	case PSTORE_TYPE_PPC_RTAS:

		part = &rtas_log_partition;

		*type = PSTORE_TYPE_PPC_RTAS;

		time->tv_sec = last_rtas_event;

		time->tv_nsec = 0;

		record->type = PSTORE_TYPE_PPC_RTAS;

		record->time.tv_sec = last_rtas_event;

		record->time.tv_nsec = 0;

		break;

	case PSTORE_TYPE_PPC_OF:

		sig = NVRAM_SIG_OF;

		part = &of_config_partition;

		*type = PSTORE_TYPE_PPC_OF;

		*id = PSTORE_TYPE_PPC_OF;

		time->tv_sec = 0;

		time->tv_nsec = 0;

		record->type = PSTORE_TYPE_PPC_OF;

		record->id = PSTORE_TYPE_PPC_OF;

		record->time.tv_sec = 0;

		record->time.tv_nsec = 0;

		break;

#endif

#ifdef CONFIG_PPC_POWERNV

	case PSTORE_TYPE_PPC_OPAL:

		sig = NVRAM_SIG_FW;

		part = &skiboot_partition;

		*type = PSTORE_TYPE_PPC_OPAL;

		*id = PSTORE_TYPE_PPC_OPAL;

		time->tv_sec = 0;

		time->tv_nsec = 0;

		record->type = PSTORE_TYPE_PPC_OPAL;

		record->id = PSTORE_TYPE_PPC_OPAL;

		record->time.tv_sec = 0;

		record->time.tv_nsec = 0;

		break;

#endif

	default:
@@ -520,10 +506,10 @@ static ssize_t nvram_pstore_read(u64 *id, enum pstore_type_id *type, 
		return 0;

	}



	*count = 0;

	record->count = 0;



	if (part->os_partition)

		*id = id_no;

		record->id = id_no;



	if (nvram_type_ids[read_type] == PSTORE_TYPE_DMESG) {

		size_t length, hdr_size;
@@ -533,34 +519,35 @@ static ssize_t nvram_pstore_read(u64 *id, enum pstore_type_id *type, 
			/* Old format oops header had 2-byte record size */

			hdr_size = sizeof(u16);

			length = be16_to_cpu(oops_hdr->version);

			time->tv_sec = 0;

			time->tv_nsec = 0;

			record->time.tv_sec = 0;

			record->time.tv_nsec = 0;

		} else {

			hdr_size = sizeof(*oops_hdr);

			length = be16_to_cpu(oops_hdr->report_length);

			time->tv_sec = be64_to_cpu(oops_hdr->timestamp);

			time->tv_nsec = 0;

			record->time.tv_sec = be64_to_cpu(oops_hdr->timestamp);

			record->time.tv_nsec = 0;

		}

		*buf = kmemdup(buff + hdr_size, length, GFP_KERNEL);

		record->buf = kmemdup(buff + hdr_size, length, GFP_KERNEL);

		kfree(buff);

		if (*buf == NULL)

		if (record->buf == NULL)

			return -ENOMEM;



		*ecc_notice_size = 0;

		record->ecc_notice_size = 0;

		if (err_type == ERR_TYPE_KERNEL_PANIC_GZ)

			*compressed = true;

			record->compressed = true;

		else

			*compressed = false;

			record->compressed = false;

		return length;

	}



	*buf = buff;

	record->buf = buff;

	return part->size;

}



static struct pstore_info nvram_pstore_info = {

	.owner = THIS_MODULE,

	.name = "nvram",

	.flags = PSTORE_FLAGS_DMESG,

	.open = nvram_pstore_open,

	.read = nvram_pstore_read,

	.write = nvram_pstore_write,

drivers/acpi/apei/erst.c

+26 −38
Original line number Diff line number Diff line
@@ -925,15 +925,9 @@ static int erst_check_table(struct acpi_table_erst *erst_tab) 


static int erst_open_pstore(struct pstore_info *psi);

static int erst_close_pstore(struct pstore_info *psi);

static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count,

			   struct timespec *time, char **buf,

			   bool *compressed, ssize_t *ecc_notice_size,

			   struct pstore_info *psi);

static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason,

		       u64 *id, unsigned int part, int count, bool compressed,

		       size_t size, struct pstore_info *psi);

static int erst_clearer(enum pstore_type_id type, u64 id, int count,

			struct timespec time, struct pstore_info *psi);

static ssize_t erst_reader(struct pstore_record *record);

static int erst_writer(struct pstore_record *record);

static int erst_clearer(struct pstore_record *record);



static struct pstore_info erst_info = {

	.owner		= THIS_MODULE,
@@ -986,10 +980,7 @@ static int erst_close_pstore(struct pstore_info *psi) 
	return 0;

}



static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count,

			   struct timespec *time, char **buf,

			   bool *compressed, ssize_t *ecc_notice_size,

			   struct pstore_info *psi)

static ssize_t erst_reader(struct pstore_record *record)

{

	int rc;

	ssize_t len = 0;
@@ -1027,42 +1018,40 @@ static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count, 
	if (uuid_le_cmp(rcd->hdr.creator_id, CPER_CREATOR_PSTORE) != 0)

		goto skip;



	*buf = kmalloc(len, GFP_KERNEL);

	if (*buf == NULL) {

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

	if (record->buf == NULL) {

		rc = -ENOMEM;

		goto out;

	}

	memcpy(*buf, rcd->data, len - sizeof(*rcd));

	*id = record_id;

	*compressed = false;

	*ecc_notice_size = 0;

	memcpy(record->buf, rcd->data, len - sizeof(*rcd));

	record->id = record_id;

	record->compressed = false;

	record->ecc_notice_size = 0;

	if (uuid_le_cmp(rcd->sec_hdr.section_type,

			CPER_SECTION_TYPE_DMESG_Z) == 0) {

		*type = PSTORE_TYPE_DMESG;

		*compressed = true;

		record->type = PSTORE_TYPE_DMESG;

		record->compressed = true;

	} else if (uuid_le_cmp(rcd->sec_hdr.section_type,

			CPER_SECTION_TYPE_DMESG) == 0)

		*type = PSTORE_TYPE_DMESG;

		record->type = PSTORE_TYPE_DMESG;

	else if (uuid_le_cmp(rcd->sec_hdr.section_type,

			     CPER_SECTION_TYPE_MCE) == 0)

		*type = PSTORE_TYPE_MCE;

		record->type = PSTORE_TYPE_MCE;

	else

		*type = PSTORE_TYPE_UNKNOWN;

		record->type = PSTORE_TYPE_UNKNOWN;



	if (rcd->hdr.validation_bits & CPER_VALID_TIMESTAMP)

		time->tv_sec = rcd->hdr.timestamp;

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

	else

		time->tv_sec = 0;

	time->tv_nsec = 0;

		record->time.tv_sec = 0;

	record->time.tv_nsec = 0;



out:

	kfree(rcd);

	return (rc < 0) ? rc : (len - sizeof(*rcd));

}



static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason,

		       u64 *id, unsigned int part, int count, bool compressed,

		       size_t size, struct pstore_info *psi)

static int erst_writer(struct pstore_record *record)

{

	struct cper_pstore_record *rcd = (struct cper_pstore_record *)

					(erst_info.buf - sizeof(*rcd));
@@ -1077,21 +1066,21 @@ static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason, 
	/* timestamp valid. platform_id, partition_id are invalid */

	rcd->hdr.validation_bits = CPER_VALID_TIMESTAMP;

	rcd->hdr.timestamp = get_seconds();

	rcd->hdr.record_length = sizeof(*rcd) + size;

	rcd->hdr.record_length = sizeof(*rcd) + record->size;

	rcd->hdr.creator_id = CPER_CREATOR_PSTORE;

	rcd->hdr.notification_type = CPER_NOTIFY_MCE;

	rcd->hdr.record_id = cper_next_record_id();

	rcd->hdr.flags = CPER_HW_ERROR_FLAGS_PREVERR;



	rcd->sec_hdr.section_offset = sizeof(*rcd);

	rcd->sec_hdr.section_length = size;

	rcd->sec_hdr.section_length = record->size;

	rcd->sec_hdr.revision = CPER_SEC_REV;

	/* fru_id and fru_text is invalid */

	rcd->sec_hdr.validation_bits = 0;

	rcd->sec_hdr.flags = CPER_SEC_PRIMARY;

	switch (type) {

	switch (record->type) {

	case PSTORE_TYPE_DMESG:

		if (compressed)

		if (record->compressed)

			rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG_Z;

		else

			rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG;
@@ -1105,15 +1094,14 @@ static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason, 
	rcd->sec_hdr.section_severity = CPER_SEV_FATAL;



	ret = erst_write(&rcd->hdr);

	*id = rcd->hdr.record_id;

	record->id = rcd->hdr.record_id;



	return ret;

}



static int erst_clearer(enum pstore_type_id type, u64 id, int count,

			struct timespec time, struct pstore_info *psi)

static int erst_clearer(struct pstore_record *record)

{

	return erst_clear(id);

	return erst_clear(record->id);

}



static int __init erst_init(void)

drivers/firmware/efi/efi-pstore.c

+62 −86
Original line number Diff line number Diff line
@@ -28,26 +28,16 @@ static int efi_pstore_close(struct pstore_info *psi) 
	return 0;

}



struct pstore_read_data {

	u64 *id;

	enum pstore_type_id *type;

	int *count;

	struct timespec *timespec;

	bool *compressed;

	ssize_t *ecc_notice_size;

	char **buf;

};



static inline u64 generic_id(unsigned long timestamp,

			     unsigned int part, int count)

{

	return ((u64) timestamp * 100 + part) * 1000 + count;

}



static int efi_pstore_read_func(struct efivar_entry *entry, void *data)

static int efi_pstore_read_func(struct efivar_entry *entry,

				struct pstore_record *record)

{

	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;

	struct pstore_read_data *cb_data = data;

	char name[DUMP_NAME_LEN], data_type;

	int i;

	int cnt;
@@ -61,37 +51,37 @@ static int efi_pstore_read_func(struct efivar_entry *entry, void *data) 
		name[i] = entry->var.VariableName[i];



	if (sscanf(name, "dump-type%u-%u-%d-%lu-%c",

		   cb_data->type, &part, &cnt, &time, &data_type) == 5) {

		*cb_data->id = generic_id(time, part, cnt);

		*cb_data->count = cnt;

		cb_data->timespec->tv_sec = time;

		cb_data->timespec->tv_nsec = 0;

		   &record->type, &part, &cnt, &time, &data_type) == 5) {

		record->id = generic_id(time, part, cnt);

		record->count = cnt;

		record->time.tv_sec = time;

		record->time.tv_nsec = 0;

		if (data_type == 'C')

			*cb_data->compressed = true;

			record->compressed = true;

		else

			*cb_data->compressed = false;

		*cb_data->ecc_notice_size = 0;

			record->compressed = false;

		record->ecc_notice_size = 0;

	} else if (sscanf(name, "dump-type%u-%u-%d-%lu",

		   cb_data->type, &part, &cnt, &time) == 4) {

		*cb_data->id = generic_id(time, part, cnt);

		*cb_data->count = cnt;

		cb_data->timespec->tv_sec = time;

		cb_data->timespec->tv_nsec = 0;

		*cb_data->compressed = false;

		*cb_data->ecc_notice_size = 0;

		   &record->type, &part, &cnt, &time) == 4) {

		record->id = generic_id(time, part, cnt);

		record->count = cnt;

		record->time.tv_sec = time;

		record->time.tv_nsec = 0;

		record->compressed = false;

		record->ecc_notice_size = 0;

	} else if (sscanf(name, "dump-type%u-%u-%lu",

			  cb_data->type, &part, &time) == 3) {

			  &record->type, &part, &time) == 3) {

		/*

		 * Check if an old format,

		 * which doesn't support holding

		 * multiple logs, remains.

		 */

		*cb_data->id = generic_id(time, part, 0);

		*cb_data->count = 0;

		cb_data->timespec->tv_sec = time;

		cb_data->timespec->tv_nsec = 0;

		*cb_data->compressed = false;

		*cb_data->ecc_notice_size = 0;

		record->id = generic_id(time, part, 0);

		record->count = 0;

		record->time.tv_sec = time;

		record->time.tv_nsec = 0;

		record->compressed = false;

		record->ecc_notice_size = 0;

	} else

		return 0;
@@ -99,7 +89,7 @@ static int efi_pstore_read_func(struct efivar_entry *entry, void *data) 
	__efivar_entry_get(entry, &entry->var.Attributes,

			   &entry->var.DataSize, entry->var.Data);

	size = entry->var.DataSize;

	memcpy(*cb_data->buf, entry->var.Data,

	memcpy(record->buf, entry->var.Data,

	       (size_t)min_t(unsigned long, EFIVARS_DATA_SIZE_MAX, size));



	return size;
@@ -164,7 +154,7 @@ static int efi_pstore_scan_sysfs_exit(struct efivar_entry *pos, 
/**

 * efi_pstore_sysfs_entry_iter

 *

 * @data: function-specific data to pass to callback

 * @record: pstore record to pass to callback

 * @pos: entry to begin iterating from

 *

 * You MUST call efivar_enter_iter_begin() before this function, and
@@ -175,7 +165,8 @@ static int efi_pstore_scan_sysfs_exit(struct efivar_entry *pos, 
 * the next entry of the last one passed to efi_pstore_read_func().

 * To begin iterating from the beginning of the list @pos must be %NULL.

 */

static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos)

static int efi_pstore_sysfs_entry_iter(struct pstore_record *record,

				       struct efivar_entry **pos)

{

	struct efivar_entry *entry, *n;

	struct list_head *head = &efivar_sysfs_list;
@@ -186,7 +177,7 @@ static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos) 
		list_for_each_entry_safe(entry, n, head, list) {

			efi_pstore_scan_sysfs_enter(entry, n, head);



			size = efi_pstore_read_func(entry, data);

			size = efi_pstore_read_func(entry, record);

			ret = efi_pstore_scan_sysfs_exit(entry, n, head,

							 size < 0);

			if (ret)
@@ -201,7 +192,7 @@ static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos) 
	list_for_each_entry_safe_from((*pos), n, head, list) {

		efi_pstore_scan_sysfs_enter((*pos), n, head);



		size = efi_pstore_read_func((*pos), data);

		size = efi_pstore_read_func((*pos), record);

		ret = efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0);

		if (ret)

			return ret;
@@ -225,71 +216,57 @@ static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos) 
 * size < 0: Failed to get data of entry logging via efi_pstore_write(),

 *           and pstore will stop reading entry.

 */

static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,

			       int *count, struct timespec *timespec,

			       char **buf, bool *compressed,

			       ssize_t *ecc_notice_size,

			       struct pstore_info *psi)

static ssize_t efi_pstore_read(struct pstore_record *record)

{

	struct pstore_read_data data;

	struct efivar_entry *entry = (struct efivar_entry *)record->psi->data;

	ssize_t size;



	data.id = id;

	data.type = type;

	data.count = count;

	data.timespec = timespec;

	data.compressed = compressed;

	data.ecc_notice_size = ecc_notice_size;

	data.buf = buf;



	*data.buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL);

	if (!*data.buf)

	record->buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL);

	if (!record->buf)

		return -ENOMEM;



	if (efivar_entry_iter_begin()) {

		kfree(*data.buf);

		return -EINTR;

		size = -EINTR;

		goto out;

	}

	size = efi_pstore_sysfs_entry_iter(&data,

					   (struct efivar_entry **)&psi->data);

	size = efi_pstore_sysfs_entry_iter(record, &entry);

	efivar_entry_iter_end();

	if (size <= 0)

		kfree(*data.buf);



out:

	if (size <= 0) {

		kfree(record->buf);

		record->buf = NULL;

	}

	return size;

}



static int efi_pstore_write(enum pstore_type_id type,

		enum kmsg_dump_reason reason, u64 *id,

		unsigned int part, int count, bool compressed, size_t size,

		struct pstore_info *psi)

static int efi_pstore_write(struct pstore_record *record)

{

	char name[DUMP_NAME_LEN];

	efi_char16_t efi_name[DUMP_NAME_LEN];

	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;

	int i, ret = 0;



	sprintf(name, "dump-type%u-%u-%d-%lu-%c", type, part, count,

		get_seconds(), compressed ? 'C' : 'D');

	snprintf(name, sizeof(name), "dump-type%u-%u-%d-%lu-%c",

		 record->type, record->part, record->count,

		 get_seconds(), record->compressed ? 'C' : 'D');



	for (i = 0; i < DUMP_NAME_LEN; i++)

		efi_name[i] = name[i];



	ret = efivar_entry_set_safe(efi_name, vendor, PSTORE_EFI_ATTRIBUTES,

				    !pstore_cannot_block_path(reason),

				    size, psi->buf);

			      !pstore_cannot_block_path(record->reason),

			      record->size, record->psi->buf);



	if (reason == KMSG_DUMP_OOPS)

	if (record->reason == KMSG_DUMP_OOPS)

		efivar_run_worker();



	*id = part;

	record->id = record->part;

	return ret;

};



struct pstore_erase_data {

	u64 id;

	enum pstore_type_id type;

	int count;

	struct timespec time;

	struct pstore_record *record;

	efi_char16_t *name;

};
@@ -315,8 +292,9 @@ static int efi_pstore_erase_func(struct efivar_entry *entry, void *data) 
		 * Check if an old format, which doesn't support

		 * holding multiple logs, remains.

		 */

		sprintf(name_old, "dump-type%u-%u-%lu", ed->type,

			(unsigned int)ed->id, ed->time.tv_sec);

		snprintf(name_old, sizeof(name_old), "dump-type%u-%u-%lu",

			ed->record->type, (unsigned int)ed->record->id,

			ed->record->time.tv_sec);



		for (i = 0; i < DUMP_NAME_LEN; i++)

			efi_name_old[i] = name_old[i];
@@ -341,8 +319,7 @@ static int efi_pstore_erase_func(struct efivar_entry *entry, void *data) 
	return 1;

}



static int efi_pstore_erase(enum pstore_type_id type, u64 id, int count,

			    struct timespec time, struct pstore_info *psi)

static int efi_pstore_erase(struct pstore_record *record)

{

	struct pstore_erase_data edata;

	struct efivar_entry *entry = NULL;
@@ -351,17 +328,16 @@ static int efi_pstore_erase(enum pstore_type_id type, u64 id, int count, 
	int found, i;

	unsigned int part;



	do_div(id, 1000);

	part = do_div(id, 100);

	sprintf(name, "dump-type%u-%u-%d-%lu", type, part, count, time.tv_sec);

	do_div(record->id, 1000);

	part = do_div(record->id, 100);

	snprintf(name, sizeof(name), "dump-type%u-%u-%d-%lu",

		 record->type, record->part, record->count,

		 record->time.tv_sec);



	for (i = 0; i < DUMP_NAME_LEN; i++)

		efi_name[i] = name[i];



	edata.id = part;

	edata.type = type;

	edata.count = count;

	edata.time = time;

	edata.record = record;

	edata.name = efi_name;



	if (efivar_entry_iter_begin())

fs/pstore/ftrace.c

+8 −3
Original line number Diff line number Diff line
@@ -37,6 +37,12 @@ static void notrace pstore_ftrace_call(unsigned long ip, 
{

	unsigned long flags;

	struct pstore_ftrace_record rec = {};

	struct pstore_record record = {

		.type = PSTORE_TYPE_FTRACE,

		.buf = (char *)&rec,

		.size = sizeof(rec),

		.psi = psinfo,

	};



	if (unlikely(oops_in_progress))

		return;
@@ -47,8 +53,7 @@ static void notrace pstore_ftrace_call(unsigned long ip, 
	rec.parent_ip = parent_ip;

	pstore_ftrace_write_timestamp(&rec, pstore_ftrace_stamp++);

	pstore_ftrace_encode_cpu(&rec, raw_smp_processor_id());

	psinfo->write_buf(PSTORE_TYPE_FTRACE, 0, NULL, 0, (void *)&rec,

			  0, sizeof(rec), psinfo);

	psinfo->write(&record);



	local_irq_restore(flags);

}
@@ -117,7 +122,7 @@ void pstore_register_ftrace(void) 
{

	struct dentry *file;



	if (!psinfo->write_buf)

	if (!psinfo->write)

		return;



	pstore_ftrace_dir = debugfs_create_dir("pstore", NULL);

fs/pstore/inode.c

+88 −59

File changed.

Preview size limit exceeded, changes collapsed.