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

Commit 07354eb1 authored by Thomas Gleixner's avatar Thomas Gleixner Committed by Ingo Molnar
Browse files

locking, printk: Annotate logbuf_lock as raw 



The logbuf_lock lock can be taken in atomic context and therefore
cannot be preempted on -rt - annotate it.

In mainline this change documents the low level nature of
the lock - otherwise there's no functional difference. Lockdep
and Sparse checking will work as usual.

Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
[ merged and fixed it ]
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent 5389f6fa

include/linux/ratelimit.h

+3 −3
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ 
#define DEFAULT_RATELIMIT_BURST		10



struct ratelimit_state {

	spinlock_t	lock;		/* protect the state */

	raw_spinlock_t	lock;		/* protect the state */



	int		interval;

	int		burst;
@@ -20,7 +20,7 @@ struct ratelimit_state { 
#define DEFINE_RATELIMIT_STATE(name, interval_init, burst_init)		\

									\

	struct ratelimit_state name = {					\

		.lock		= __SPIN_LOCK_UNLOCKED(name.lock),	\

		.lock		= __RAW_SPIN_LOCK_UNLOCKED(name.lock),	\

		.interval	= interval_init,			\

		.burst		= burst_init,				\

	}
@@ -28,7 +28,7 @@ struct ratelimit_state { 
static inline void ratelimit_state_init(struct ratelimit_state *rs,

					int interval, int burst)

{

	spin_lock_init(&rs->lock);

	raw_spin_lock_init(&rs->lock);

	rs->interval = interval;

	rs->burst = burst;

	rs->printed = 0;

kernel/printk.c

+23 −23
Original line number Diff line number Diff line
@@ -100,7 +100,7 @@ static int console_locked, console_suspended; 
 * It is also used in interesting ways to provide interlocking in

 * console_unlock();.

 */

static DEFINE_SPINLOCK(logbuf_lock);

static DEFINE_RAW_SPINLOCK(logbuf_lock);



#define LOG_BUF_MASK (log_buf_len-1)

#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
@@ -212,7 +212,7 @@ void __init setup_log_buf(int early) 
		return;

	}



	spin_lock_irqsave(&logbuf_lock, flags);

	raw_spin_lock_irqsave(&logbuf_lock, flags);

	log_buf_len = new_log_buf_len;

	log_buf = new_log_buf;

	new_log_buf_len = 0;
@@ -230,7 +230,7 @@ void __init setup_log_buf(int early) 
	log_start -= offset;

	con_start -= offset;

	log_end -= offset;

	spin_unlock_irqrestore(&logbuf_lock, flags);

	raw_spin_unlock_irqrestore(&logbuf_lock, flags);



	pr_info("log_buf_len: %d\n", log_buf_len);

	pr_info("early log buf free: %d(%d%%)\n",
@@ -365,18 +365,18 @@ int do_syslog(int type, char __user *buf, int len, bool from_file) 
		if (error)

			goto out;

		i = 0;

		spin_lock_irq(&logbuf_lock);

		raw_spin_lock_irq(&logbuf_lock);

		while (!error && (log_start != log_end) && i < len) {

			c = LOG_BUF(log_start);

			log_start++;

			spin_unlock_irq(&logbuf_lock);

			raw_spin_unlock_irq(&logbuf_lock);

			error = __put_user(c,buf);

			buf++;

			i++;

			cond_resched();

			spin_lock_irq(&logbuf_lock);

			raw_spin_lock_irq(&logbuf_lock);

		}

		spin_unlock_irq(&logbuf_lock);

		raw_spin_unlock_irq(&logbuf_lock);

		if (!error)

			error = i;

		break;
@@ -399,7 +399,7 @@ int do_syslog(int type, char __user *buf, int len, bool from_file) 
		count = len;

		if (count > log_buf_len)

			count = log_buf_len;

		spin_lock_irq(&logbuf_lock);

		raw_spin_lock_irq(&logbuf_lock);

		if (count > logged_chars)

			count = logged_chars;

		if (do_clear)
@@ -416,12 +416,12 @@ int do_syslog(int type, char __user *buf, int len, bool from_file) 
			if (j + log_buf_len < log_end)

				break;

			c = LOG_BUF(j);

			spin_unlock_irq(&logbuf_lock);

			raw_spin_unlock_irq(&logbuf_lock);

			error = __put_user(c,&buf[count-1-i]);

			cond_resched();

			spin_lock_irq(&logbuf_lock);

			raw_spin_lock_irq(&logbuf_lock);

		}

		spin_unlock_irq(&logbuf_lock);

		raw_spin_unlock_irq(&logbuf_lock);

		if (error)

			break;

		error = i;
@@ -689,7 +689,7 @@ static void zap_locks(void) 
	oops_timestamp = jiffies;



	/* If a crash is occurring, make sure we can't deadlock */

	spin_lock_init(&logbuf_lock);

	raw_spin_lock_init(&logbuf_lock);

	/* And make sure that we print immediately */

	sema_init(&console_sem, 1);

}
@@ -802,9 +802,9 @@ static int console_trylock_for_printk(unsigned int cpu) 
		}

	}

	printk_cpu = UINT_MAX;

	spin_unlock(&logbuf_lock);

	if (wake)

		up(&console_sem);

	raw_spin_unlock(&logbuf_lock);

	return retval;

}

static const char recursion_bug_msg [] =
@@ -864,7 +864,7 @@ asmlinkage int vprintk(const char *fmt, va_list args) 
	}



	lockdep_off();

	spin_lock(&logbuf_lock);

	raw_spin_lock(&logbuf_lock);

	printk_cpu = this_cpu;



	if (recursion_bug) {
@@ -1257,14 +1257,14 @@ void console_unlock(void) 


again:

	for ( ; ; ) {

		spin_lock_irqsave(&logbuf_lock, flags);

		raw_spin_lock_irqsave(&logbuf_lock, flags);

		wake_klogd |= log_start - log_end;

		if (con_start == log_end)

			break;			/* Nothing to print */

		_con_start = con_start;

		_log_end = log_end;

		con_start = log_end;		/* Flush */

		spin_unlock(&logbuf_lock);

		raw_spin_unlock(&logbuf_lock);

		stop_critical_timings();	/* don't trace print latency */

		call_console_drivers(_con_start, _log_end);

		start_critical_timings();
@@ -1276,7 +1276,7 @@ void console_unlock(void) 
	if (unlikely(exclusive_console))

		exclusive_console = NULL;



	spin_unlock(&logbuf_lock);

	raw_spin_unlock(&logbuf_lock);



	up(&console_sem);
@@ -1286,13 +1286,13 @@ void console_unlock(void) 
	 * there's a new owner and the console_unlock() from them will do the

	 * flush, no worries.

	 */

	spin_lock(&logbuf_lock);

	raw_spin_lock(&logbuf_lock);

	if (con_start != log_end)

		retry = 1;

	spin_unlock_irqrestore(&logbuf_lock, flags);

	if (retry && console_trylock())

		goto again;



	raw_spin_unlock_irqrestore(&logbuf_lock, flags);

	if (wake_klogd)

		wake_up_klogd();

}
@@ -1522,9 +1522,9 @@ void register_console(struct console *newcon) 
		 * console_unlock(); will print out the buffered messages

		 * for us.

		 */

		spin_lock_irqsave(&logbuf_lock, flags);

		raw_spin_lock_irqsave(&logbuf_lock, flags);

		con_start = log_start;

		spin_unlock_irqrestore(&logbuf_lock, flags);

		raw_spin_unlock_irqrestore(&logbuf_lock, flags);

		/*

		 * We're about to replay the log buffer.  Only do this to the

		 * just-registered console to avoid excessive message spam to
@@ -1731,10 +1731,10 @@ void kmsg_dump(enum kmsg_dump_reason reason) 
	/* Theoretically, the log could move on after we do this, but

	   there's not a lot we can do about that. The new messages

	   will overwrite the start of what we dump. */

	spin_lock_irqsave(&logbuf_lock, flags);

	raw_spin_lock_irqsave(&logbuf_lock, flags);

	end = log_end & LOG_BUF_MASK;

	chars = logged_chars;

	spin_unlock_irqrestore(&logbuf_lock, flags);

	raw_spin_unlock_irqrestore(&logbuf_lock, flags);



	if (chars > end) {

		s1 = log_buf + log_buf_len - chars + end;

lib/ratelimit.c

+2 −2
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ int ___ratelimit(struct ratelimit_state *rs, const char *func) 
	 * in addition to the one that will be printed by

	 * the entity that is holding the lock already:

	 */

	if (!spin_trylock_irqsave(&rs->lock, flags))

	if (!raw_spin_trylock_irqsave(&rs->lock, flags))

		return 0;



	if (!rs->begin)
@@ -60,7 +60,7 @@ int ___ratelimit(struct ratelimit_state *rs, const char *func) 
		rs->missed++;

		ret = 0;

	}

	spin_unlock_irqrestore(&rs->lock, flags);

	raw_spin_unlock_irqrestore(&rs->lock, flags);



	return ret;

}