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

Commit 10b24199 authored by Tim Bird's avatar Tim Bird Committed by Greg Kroah-Hartman
Browse files

staging: android: logger: Allocate logs dynamically at boot (v3) 



This changes the log initialization to be dynamic, but still
at boot time.  These changes are a predecessor to implementing
runtime allocation and freeing of logs, to make the Android logger
less hard-coded.

Change from a fixed set of static log structures, to allocation
at init time into a list.  Return proper error numbers on log
allocation failure.

Cc: Brian Swetland <swetland@google.com>
Signed-off-by: default avatarTim Bird <tim.bird@am.sony.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 9a0fbbb5

drivers/staging/android/logger.c

+62 −45
Original line number Original line Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include <linux/poll.h>

#include <linux/poll.h>

#include <linux/slab.h>

#include <linux/slab.h>

#include <linux/time.h>

#include <linux/time.h>

#include <linux/vmalloc.h>

#include "logger.h"

#include "logger.h"





#include <asm/ioctls.h>

#include <asm/ioctls.h>
@@ -45,8 +46,12 @@ struct logger_log { 
	size_t			w_off;	/* current write head offset */

	size_t			w_off;	/* current write head offset */

	size_t			head;	/* new readers start here */

	size_t			head;	/* new readers start here */

	size_t			size;	/* size of the log */

	size_t			size;	/* size of the log */

	struct list_head	logs;	/* list of log channels (myself)*/

};

};





static LIST_HEAD(log_list);





/*

/*

 * struct logger_reader - a logging device open for reading

 * struct logger_reader - a logging device open for reading

 *

 *
@@ -408,7 +413,15 @@ ssize_t logger_aio_write(struct kiocb *iocb, const struct iovec *iov, 
	return ret;

	return ret;

}

}





static struct logger_log *get_log_from_minor(int);

static struct logger_log *get_log_from_minor(int minor)

{

	struct logger_log *log;



	list_for_each_entry(log, &log_list, logs)

		if (log->misc.minor == minor)

			return log;

	return NULL;

}





/*

/*

 * logger_open - the log's open() file operation

 * logger_open - the log's open() file operation
@@ -565,80 +578,84 @@ static const struct file_operations logger_fops = { 
};

};





/*

/*

 * Defines a log structure with name 'NAME' and a size of 'SIZE' bytes, which

 * Log size must be a power of two, greater than LOGGER_ENTRY_MAX_LEN,

 * must be a power of two, greater than LOGGER_ENTRY_MAX_LEN, and less than

 * and less than LONG_MAX minus LOGGER_ENTRY_MAX_LEN.

 * LONG_MAX minus LOGGER_ENTRY_MAX_LEN.

 */

 */

#define DEFINE_LOGGER_DEVICE(VAR, NAME, SIZE) \

static int __init create_log(char *log_name, int size)

static unsigned char _buf_ ## VAR[SIZE]; \

{

static struct logger_log VAR = { \

	int ret = 0;

	.buffer = _buf_ ## VAR, \

	struct logger_log *log;

	.misc = { \

	unsigned char *buffer;

		.minor = MISC_DYNAMIC_MINOR, \

		.name = NAME, \

		.fops = &logger_fops, \

		.parent = NULL, \

	}, \

	.wq = __WAIT_QUEUE_HEAD_INITIALIZER(VAR .wq), \

	.readers = LIST_HEAD_INIT(VAR .readers), \

	.mutex = __MUTEX_INITIALIZER(VAR .mutex), \

	.w_off = 0, \

	.head = 0, \

	.size = SIZE, \

};





DEFINE_LOGGER_DEVICE(log_main, LOGGER_LOG_MAIN, 256*1024)

	buffer = vmalloc(size);

DEFINE_LOGGER_DEVICE(log_events, LOGGER_LOG_EVENTS, 256*1024)

	if (buffer == NULL)

DEFINE_LOGGER_DEVICE(log_radio, LOGGER_LOG_RADIO, 256*1024)

		return -ENOMEM;

DEFINE_LOGGER_DEVICE(log_system, LOGGER_LOG_SYSTEM, 256*1024)





static struct logger_log *get_log_from_minor(int minor)

	log = kzalloc(sizeof(struct logger_log), GFP_KERNEL);

{

	if (log == NULL) {

	if (log_main.misc.minor == minor)

		ret = -ENOMEM;

		return &log_main;

		goto out_free_buffer;

	if (log_events.misc.minor == minor)

		return &log_events;

	if (log_radio.misc.minor == minor)

		return &log_radio;

	if (log_system.misc.minor == minor)

		return &log_system;

	return NULL;

	}

	}

	log->buffer = buffer;





static int __init init_log(struct logger_log *log)

	log->misc.minor = MISC_DYNAMIC_MINOR;

{

	log->misc.name = kstrdup(log_name, GFP_KERNEL);

	int ret;

	if (log->misc.name == NULL) {

		ret = -ENOMEM;

		goto out_free_log;

	}



	log->misc.fops = &logger_fops;

	log->misc.parent = NULL;





	init_waitqueue_head(&log->wq);

	INIT_LIST_HEAD(&log->readers);

	mutex_init(&log->mutex);

	log->w_off = 0;

	log->head = 0;

	log->size = size;



	INIT_LIST_HEAD(&log->logs);

	list_add_tail(&log->logs, &log_list);



	/* finally, initialize the misc device for this log */

	ret = misc_register(&log->misc);

	ret = misc_register(&log->misc);

	if (unlikely(ret)) {

	if (unlikely(ret)) {

		printk(KERN_ERR "logger: failed to register misc "

		printk(KERN_ERR "logger: failed to register misc "

		       "device for log '%s'!\n", log->misc.name);

		       "device for log '%s'!\n", log->misc.name);

		return ret;

		goto out_free_log;

	}

	}





	printk(KERN_INFO "logger: created %luK log '%s'\n",

	printk(KERN_INFO "logger: created %luK log '%s'\n",

	       (unsigned long) log->size >> 10, log->misc.name);

	       (unsigned long) log->size >> 10, log->misc.name);





	return 0;

	return 0;



out_free_log:

	kfree(log);



out_free_buffer:

	vfree(buffer);

	return ret;

}

}





static int __init logger_init(void)

static int __init logger_init(void)

{

{

	int ret;

	int ret;





	ret = init_log(&log_main);

	ret = create_log(LOGGER_LOG_MAIN, 256*1024);

	if (unlikely(ret))

	if (unlikely(ret))

		goto out;

		goto out;





	ret = init_log(&log_events);

	ret = create_log(LOGGER_LOG_EVENTS, 256*1024);

	if (unlikely(ret))

	if (unlikely(ret))

		goto out;

		goto out;





	ret = init_log(&log_radio);

	ret = create_log(LOGGER_LOG_RADIO, 256*1024);

	if (unlikely(ret))

	if (unlikely(ret))

		goto out;

		goto out;





	ret = init_log(&log_system);

	ret = create_log(LOGGER_LOG_SYSTEM, 256*1024);

	if (unlikely(ret))

	if (unlikely(ret))

		goto out;

		goto out;