Reading a configfs file - file

Question

I am writing an user space process that will read data from the configfs entry continuously. I have defined callback function for read in kernel.
When I invoke read in a loop, only for the first time callback is called and for the next iterations control is not hitting the callback.
Kernel callback for read is simple function that will return a character.
static ssize_t show(struct config_item *item, char *page)
{
static char a = 'a';
printk("reading data\n");
page[0] = a++;
return 1;
}
User space process will read the data and display it on the screen.
int main()
{
int fd = open("/sys/kernel/config/sample/showme", O_RDONLY);
int ret;
int i = 5;
char receive[8];
if (fd < 0) {
perror("Failed to open the device...");
return errno;
}
while(i--) {
ret = read(fd, receive, 1);
if (ret < 0) {
perror("Failed to read the message\n");
return errno;
}
printf("Message is %x with size %d\n", receive[0], ret);
}
close(fd);
}
output:
Message is 61 with size 1
Message is 61 with size 0
Message is 61 with size 0
Message is 61 with size 0
Message is 61 with size 0
Note: The flow goes well if I close and open the file for all reads.
How to fix the above problem? I want the data to be reflected on all read.

Answer 1

A file under configfs filesystem is interpreted as an attribute, which have specific finite content at any moment.
E.g., a file may have content:
"123" at moment 1ns
"abc" at moment 2ns
"" (empty) at moment 3ns
and so on.
Moreover, configfs filesystem ensures, that after opening the file, any read() performed by the user will see portion of data consistent with other read()s. Assuming the example above, user won't read first symbol "1" (as at moment 1ns), 2nd symbol "b" (as at moment 2ns) and then found 3d symbol to be absent (as at moment 3ns).
So, after opening the file, .show() method is called once, and is expected to return whole content of the file. This content (or an appropriate portion of it) is returned upon futher read requests from the user.
Consistency guarantee is cleared at closing the file; so when you open it again, .show() will be called once more, and user's read requests will return updated content of the file.
I am writing an user space process that will read data from the configfs entry continuously.
With this semantic abstraction of finite file's content is lost, so you cannot implement that for configfs files.
However, you may implement this semantic with any "general" filesystem, which allows directly to set file_operations callbacks. You may create a file, e.g., under debugfs (/sys/kernel/debug/):
ssize_t my_read (struct file * filp, char __user * buf, size_t size, loff_t * offp)
{
static char a = 'a';
printk("reading data\n");
a++;
copy_to_user(buf, &a, 1);
return 1;
}
struct file_operations my_ops = {
.owner = THIS_MODULE,
.read = &my_read
};
int module_init(void)
{
debugfs_create_file("showme", S_IRUGO, NULL, NULL, &my_ops);
...
}