kernel/bpf/log.c

16 static bool bpf_verifier_log_attr_valid(const struct bpf_verifier_log *log)
19 	if (!!log->ubuf != !!log->len_total)
21 	/* log buf without log_level is meaningless */
22 	if (log->ubuf && log->level == 0)
24 	if (log->level & ~BPF_LOG_MASK)
26 	if (log->len_total > UINT_MAX >> 2)
31 int bpf_vlog_init(struct bpf_verifier_log *log, u32 log_level,
34 	log->level = log_level;
35 	log->ubuf = log_buf;
36 	log->len_total = log_size;
38 	/* log attributes have to be sane */
39 	if (!bpf_verifier_log_attr_valid(log))
45 static void bpf_vlog_update_len_max(struct bpf_verifier_log *log, u32 add_len)
48 	u64 len = log->end_pos + add_len;
50 	/* log->len_max could be larger than our current len due to
55 		log->len_max = UINT_MAX;
56 	else if (len > log->len_max)
57 		log->len_max = len;
60 void bpf_verifier_vlog(struct bpf_verifier_log *log, const char *fmt,
66 	n = vscnprintf(log->kbuf, BPF_VERIFIER_TMP_LOG_SIZE, fmt, args);
68 	if (log->level == BPF_LOG_KERNEL) {
69 		bool newline = n > 0 && log->kbuf[n - 1] == '\n';
71 		pr_err("BPF: %s%s", log->kbuf, newline ? "" : "\n");
76 	bpf_vlog_update_len_max(log, n);
78 	if (log->level & BPF_LOG_FIXED) {
81 		if (log->end_pos < log->len_total) {
82 			new_n = min_t(u32, log->len_total - log->end_pos, n);
83 			log->kbuf[new_n - 1] = '\0';
86 		cur_pos = log->end_pos;
87 		log->end_pos += n - 1; /* don't count terminating '\0' */
89 		if (log->ubuf && new_n &&
90 		    copy_to_user(log->ubuf + cur_pos, log->kbuf, new_n))
96 		new_end = log->end_pos + n;
97 		if (new_end - log->start_pos >= log->len_total)
98 			new_start = new_end - log->len_total;
100 			new_start = log->start_pos;
102 		log->start_pos = new_start;
103 		log->end_pos = new_end - 1; /* don't count terminating '\0' */
105 		if (!log->ubuf)
108 		new_n = min(n, log->len_total);
110 		div_u64_rem(cur_pos, log->len_total, &buf_start);
111 		div_u64_rem(new_end, log->len_total, &buf_end);
117 			buf_end = log->len_total;
127 			if (copy_to_user(log->ubuf + buf_start,
128 					 log->kbuf + n - new_n,
133 			if (copy_to_user(log->ubuf + buf_start,
134 					 log->kbuf + n - new_n,
135 					 log->len_total - buf_start))
137 			if (copy_to_user(log->ubuf,
138 					 log->kbuf + n - buf_end,
146 	log->ubuf = NULL;
149 void bpf_vlog_reset(struct bpf_verifier_log *log, u64 new_pos)
154 	if (WARN_ON_ONCE(new_pos > log->end_pos))
157 	if (!bpf_verifier_log_needed(log) || log->level == BPF_LOG_KERNEL)
160 	/* if position to which we reset is beyond current log window,
162 	 * start_pos to end up with an empty log (start_pos == end_pos)
164 	log->end_pos = new_pos;
165 	if (log->end_pos < log->start_pos)
166 		log->start_pos = log->end_pos;
168 	if (!log->ubuf)
171 	if (log->level & BPF_LOG_FIXED)
172 		pos = log->end_pos + 1;
174 		div_u64_rem(new_pos, log->len_total, &pos);
176 	if (pos < log->len_total && put_user(zero, log->ubuf + pos))
177 		log->ubuf = NULL;
188 static int bpf_vlog_reverse_ubuf(struct bpf_verifier_log *log, int start, int end)
190 	/* we split log->kbuf into two equal parts for both ends of array */
191 	int n = sizeof(log->kbuf) / 2, nn;
192 	char *lbuf = log->kbuf, *rbuf = log->kbuf + n;
203 		if (copy_from_user(lbuf, log->ubuf + start, nn))
205 		if (copy_from_user(rbuf, log->ubuf + end - nn, nn))
214 		if (copy_to_user(log->ubuf + start, rbuf, nn))
216 		if (copy_to_user(log->ubuf + end - nn, lbuf, nn))
226 int bpf_vlog_finalize(struct bpf_verifier_log *log, u32 *log_size_actual)
232 	if (!log || log->level == 0 || log->level == BPF_LOG_KERNEL)
235 	if (!log->ubuf)
237 	/* If we never truncated log, there is nothing to move around. */
238 	if (log->start_pos == 0)
241 	/* Otherwise we need to rotate log contents to make it start from the
243 	 * that if log->start_pos != 0 then we definitely filled up entire log
245 	 * the left by (log->start_pos % log->len_total) bytes.
253 	 * Let's say we have log buffer that has to be shifted left by 7 bytes
264 	 * We'll utilize log->kbuf to read user memory chunk by chunk, swap
274 	div_u64_rem(log->start_pos, log->len_total, &sublen);
275 	sublen = log->len_total - sublen;
277 	err = bpf_vlog_reverse_ubuf(log, 0, log->len_total);
278 	err = err ?: bpf_vlog_reverse_ubuf(log, 0, sublen);
279 	err = err ?: bpf_vlog_reverse_ubuf(log, sublen, log->len_total);
281 		log->ubuf = NULL;
284 	*log_size_actual = log->len_max;
286 	/* properly initialized log has either both ubuf!=NULL and len_total>0
290 	if (!!log->ubuf != !!log->len_total)
294 	if (log->ubuf && log->len_max > log->len_total)
301  * bpf_verifier_log_write() is used to dump the verification trace to the log,
309 	if (!bpf_verifier_log_needed(&env->log))
313 	bpf_verifier_vlog(&env->log, fmt, args);
318 __printf(2, 3) void bpf_log(struct bpf_verifier_log *log,
323 	if (!bpf_verifier_log_needed(log))
327 	bpf_verifier_vlog(log, fmt, args);
389 	if (!bpf_verifier_log_needed(&env->log))
399 	 * log doesn't emit column information, from user perspective we just
413 		bpf_verifier_vlog(&env->log, prefix_fmt, args);
868 	if (env->prev_log_pos && env->prev_log_pos == env->log.end_pos) {
870 		bpf_vlog_reset(&env->log, env->prev_log_pos - 1);