if sb->s_size == 0
return (-EINVAL);

or

MPASS(sb->s_size != 0);

What if the length is equal to the buffer size?

You are repeating strlen(buf), should cache value in a variable.

BSD style: All return values should be wrapped by ()'s.

We don't include "$FreeBSD$" in new files. Typically you'd add a copyright statement instead of a simple "written by."

Isn't lindebugfs solely for supporting drivers using the LinuxKPI? If so I'd suggest stating that directly. In other words, this is not a general-purpose filesystem but rather 1) exists mostly for the benefit of developers, and 2) only for LinuxKPI-based drivers.

Oh, this filesystem should really be called "lindebugfs".

You need to update share/man/man5/Makefile to ensure that this makefile gets installed.

Declaring variable-length arrays on the stack is not a good idea. Kernel threads have limited stack space and only primitive means of detecting stack overflow (one guard page at the end of the stack). You should malloc() a temporary buffer instead.

What does "this behaviour" refer to exactly?

Why is this commented out?

I think this could probably be committed separately?

Is this a bug fix?

Style, continuation lines should be indented by four spaces.

buf has a __user annotation, which indicates that buf is a userspace pointer. If that's actually the case (i.e., the annotation is correct), then we must not dereference the user pointer directly. Data should be copied into the kernel's address space first, then kstrtoull() can be called.

Also I don't think this call needs to happen under the mutex?

If there is no return value, you can skip the return statement. Ditto for the other cases below.

off-by-one ??

I think this is off-by-one. Should be:

*ppos >= sizeof(data)

Do you agree?

In this error case you should call d->dm_fops->release() before returning ?

In other words,

set "rc" and goto below ?

Can you make this a static inline function, instead of using a macro?

static inline loff_t
default_llseek(....)

This avoids the macro, which may match more than it should.

Please remove this comment.

This doesn't work for anything but your specific case most likely. The read implementations are expecting a user address and not a kernel one returned from malloc; this makes a lot of debugfs implementations fail with -EFAULT.

The buf[0] = '\0' exists for situations where nothing is written into buf. A good example is the seq_file ->read() implementation which uses seq_printfs to print into its local sbuf instead of writing into buf. Other ->read() implementations write file contents into buf and return their own error codes when read failures occur.

I could do if (sbuf_len(sb) == 0) { sbuf_bcpy(sb, buf, strlen(buf)) } to see if a seq_printf went through and sbuf_bcpy based on that, but I feel like the existing code is more readable.

Either way, I need the buf[0] = '\0' for strlen(). Please tell me if I am misunderstanding.

If the length is equal to the buffer size, the if statement will go through. Perhaps I am not understanding what you're suggesting?

The compiler (assuming optimizations are turned on) should optimize this out and cache the strlen() value.

Absolutely. Silly mistake on my part. Thanks for pointing that out.

Got it. I will change that! :)

Yes.

After some investigation, it appears that strscpy will error out during a zero byte transfer. I am going to apply your suggestion to make the error message more transparent. Thanks.

I do agree. I'm also changing sizeof(data) to strlen(buf) since this function applies the offset to buf, not data. Thanks for pointing that out.

The buffer was meant to be a userspace pointer at one time, but lindebugfs uses sbufs to transfer data. I am under the impression that the user to kernel space conversion has already been done by pseudofs in pseudofs_vnops.c:1082. If I use LinuxKPI's copy_from_user() on the data in buf, I get errors. I will remove the misleading __user.

The mutex is necessary if multiple simple_attr_write()s are executed at the same time asynchronously. We don't want multiple sources overwriting each other.