1// SPDX-License-Identifier: GPL-3.0-only
2
3#define pr_fmt(fmt) "sysfs: " fmt
4#include "mos/filesystem/sysfs/sysfs.hpp"
5
6#include "mos/filesystem/dentry.hpp"
7#include "mos/filesystem/vfs.hpp"
8#include "mos/filesystem/vfs_types.hpp"
9#include "mos/filesystem/vfs_utils.hpp"
10#include "mos/misc/setup.hpp"
11#include "mos/mm/mm.hpp"
12#include "mos/mm/physical/pmm.hpp"
13#include "mos/syslog/printk.hpp"
14
15#include <algorithm>
16#include <mos/filesystem/fs_types.h>
17#include <mos/io/io_types.h>
18#include <mos/lib/structures/list.hpp>
19#include <mos/type_utils.hpp>
20#include <mos/types.hpp>
21#include <mos_stdio.hpp>
22#include <mos_stdlib.hpp>
23#include <mos_string.hpp>
24
25struct sysfs_file_t : mos::NamedType<"SysFS.File">
26{
27 sysfs_item_t *item;
28
29 phyframe_t *buf_page;
30 ssize_t buf_head_offset;
31 ssize_t buf_npages;
32
33 void *data;
34};
35
36static list_head sysfs_dirs;
37extern filesystem_t fs_sysfs;
38static superblock_t *sysfs_sb = NULL;
39static const file_ops_t sysfs_dir_file_ops = { .open: 0 };
40
41static void sysfs_do_register(sysfs_dir_t *sysfs_dir);
42
43static u64 sysfs_get_ino(void)
44{
45 static u64 ino = 1;
46 return ino++;
47}
48
49void sysfs_register(sysfs_dir_t *dir)
50{
51 linked_list_init(list_node(dir));
52 list_node_append(head: &sysfs_dirs, list_node(dir));
53 pr_dinfo2(sysfs, "registering '%s'", dir->name.c_str());
54 MOS_ASSERT(sysfs_sb);
55 sysfs_do_register(sysfs_dir: dir);
56}
57
58static void sysfs_expand_buffer(sysfs_file_t *buffer, size_t new_npages)
59{
60 phyframe_t *oldbuf_page = buffer->buf_page;
61 const size_t oldbuf_npages = buffer->buf_npages;
62
63 // We need to allocate more pages
64 buffer->buf_npages = new_npages;
65 buffer->buf_page = mm_get_free_pages(npages: buffer->buf_npages);
66
67 if (oldbuf_page)
68 {
69 memcpy(dest: (char *) phyframe_va(buffer->buf_page), src: (char *) phyframe_va(oldbuf_page), n: oldbuf_npages * MOS_PAGE_SIZE);
70 mm_free_pages(oldbuf_page, oldbuf_npages);
71 }
72}
73
74ssize_t sysfs_printf(sysfs_file_t *file, const char *fmt, ...)
75{
76retry_printf:;
77 const size_t spaces_left = file->buf_npages * MOS_PAGE_SIZE - file->buf_head_offset;
78
79 va_list args;
80 va_start(args, fmt);
81 const size_t should_write = vsnprintf(buf: (char *) phyframe_va(file->buf_page) + file->buf_head_offset, size: spaces_left, format: fmt, args);
82 va_end(args);
83
84 if (should_write >= spaces_left)
85 {
86 sysfs_expand_buffer(buffer: file, new_npages: file->buf_npages + 1);
87 goto retry_printf;
88 }
89
90 file->buf_head_offset += should_write;
91 return should_write;
92}
93
94ssize_t sysfs_put_data(sysfs_file_t *file, const void *data, size_t count)
95{
96 const size_t spaces_left = file->buf_npages * MOS_PAGE_SIZE - file->buf_head_offset;
97
98 if (count > spaces_left)
99 sysfs_expand_buffer(buffer: file, new_npages: file->buf_npages + (count - spaces_left) / MOS_PAGE_SIZE + 1);
100
101 memcpy(dest: (char *) phyframe_va(file->buf_page) + file->buf_head_offset, src: data, n: count);
102 file->buf_head_offset += count;
103 return count;
104}
105
106void sysfs_file_set_data(sysfs_file_t *file, void *data)
107{
108 file->data = data;
109}
110
111void *sysfs_file_get_data(sysfs_file_t *file)
112{
113 return file->data;
114}
115
116sysfs_item_t *sysfs_file_get_item(sysfs_file_t *file)
117{
118 return file->item;
119}
120
121static bool sysfs_fops_open(inode_t *inode, file_t *file, bool created)
122{
123 MOS_UNUSED(created);
124 sysfs_file_t *sysfs_file = mos::create<sysfs_file_t>();
125 sysfs_file->item = (sysfs_item_t *) inode->private_data;
126
127 file->private_data = sysfs_file;
128 return true;
129}
130
131static void sysfs_fops_release(file_t *file)
132{
133 pr_dinfo2(sysfs, "closing %s in %s", file->dentry->name.c_str(), dentry_parent(*file->dentry)->name.c_str());
134 sysfs_file_t *f = (sysfs_file_t *) file->private_data;
135 if (f->buf_page)
136 mm_free_pages(f->buf_page, f->buf_npages), f->buf_page = NULL, f->buf_npages = 0, f->buf_head_offset = 0;
137 delete f;
138}
139
140__nodiscard static bool sysfs_file_ensure_ready(const file_t *file)
141{
142 sysfs_file_t *f = (sysfs_file_t *) file->private_data;
143 if (f->buf_head_offset == 0)
144 {
145 if (!f->item->show(f))
146 return false;
147 }
148
149 return true;
150}
151
152static ssize_t sysfs_fops_read(const file_t *file, void *buf, size_t size, off_t offset)
153{
154 sysfs_file_t *f = (sysfs_file_t *) file->private_data;
155 if (f->item->type != SYSFS_RO && f->item->type != SYSFS_RW)
156 return -ENOTSUP;
157
158 if (!sysfs_file_ensure_ready(file))
159 return -ETXTBSY;
160
161 if (offset >= f->buf_head_offset)
162 return 0;
163
164 const char *const buf_va = (char *) phyframe_va(f->buf_page);
165 const size_t begin = offset;
166 const size_t end = std::min(a: offset + size, b: (size_t) f->buf_head_offset);
167
168 memcpy(dest: (char *) buf, src: buf_va + begin, n: end - begin);
169 return end - begin;
170}
171
172static ssize_t sysfs_fops_write(const file_t *file, const void *buf, size_t size, off_t offset)
173{
174 sysfs_file_t *f = (sysfs_file_t *) file->private_data;
175 if (f->item->type != SYSFS_WO && f->item->type != SYSFS_RW)
176 return -ENOTSUP;
177 return f->item->store(f, (const char *) buf, size, offset);
178}
179
180static off_t sysfs_fops_seek(file_t *file, off_t offset, io_seek_whence_t whence)
181{
182 if (offset != 0)
183 return -1; // cannot change its internal buffer state
184
185 if (whence == IO_SEEK_DATA || whence == IO_SEEK_HOLE)
186 return -1; // not supported
187
188 if (whence == IO_SEEK_SET)
189 return -1;
190
191 sysfs_file_t *f = (sysfs_file_t *) file->private_data;
192
193 if (f->item->type == SYSFS_MEM)
194 return -1;
195
196 if (!sysfs_file_ensure_ready(file))
197 return -1;
198
199 return f->buf_head_offset;
200}
201
202bool sysfs_fops_mmap(file_t *file, vmap_t *vmap, off_t offset)
203{
204 MOS_UNUSED(vmap);
205 MOS_UNUSED(offset);
206
207 sysfs_file_t *f = (sysfs_file_t *) file->private_data;
208 if (f->item->type == SYSFS_MEM)
209 {
210 return f->item->mem.mmap(f, vmap, offset);
211 }
212 else
213 {
214 if (!sysfs_file_ensure_ready(file))
215 return false;
216
217 if (offset > f->buf_head_offset)
218 return false; // cannot map past the end of the file
219 }
220
221 return true;
222}
223
224bool sysfs_fops_munmap(file_t *file, vmap_t *vmap, bool *unmapped)
225{
226 sysfs_file_t *f = (sysfs_file_t *) file->private_data;
227 if (f->item->type == SYSFS_MEM)
228 {
229 return f->item->mem.munmap(f, vmap, unmapped);
230 }
231
232 return true;
233}
234
235static const file_ops_t sysfs_file_ops = {
236 .open = sysfs_fops_open,
237 .read = sysfs_fops_read,
238 .write = sysfs_fops_write,
239 .release = sysfs_fops_release,
240 .seek = sysfs_fops_seek,
241 .mmap = sysfs_fops_mmap,
242 .munmap = sysfs_fops_munmap,
243};
244
245static void sysfs_iops_iterate_dir(dentry_t *dentry, vfs_listdir_state_t *state, dentry_iterator_op add_record)
246{
247 // root directory
248 if (dentry->inode == sysfs_sb->root->inode)
249 {
250 // list all the directories in the dcache
251 vfs_generic_iterate_dir(dir: dentry, state, op: add_record);
252 return;
253 }
254
255 sysfs_dir_t *dir = (sysfs_dir_t *) dentry->inode->private_data;
256 MOS_ASSERT_X(dir, "invalid sysfs entry, possibly a VFS bug");
257
258 // non-dynamic directory
259 if (list_is_empty(head: &dir->_dynamic_items))
260 {
261 vfs_generic_iterate_dir(dir: dentry, state, op: add_record);
262 return;
263 }
264
265 for (size_t j = 0; j < dir->num_items; j++)
266 {
267 sysfs_item_t *item = &dir->items[j];
268 if (item->type == _SYSFS_INVALID || item->type == SYSFS_DYN)
269 continue;
270
271 add_record(state, item->ino, item->name, FILE_TYPE_REGULAR);
272 }
273
274 // iterate the dynamic items
275 list_node_foreach(item_node, &dir->_dynamic_items)
276 {
277 sysfs_item_t *const dynitem = container_of(item_node, sysfs_item_t, list_node);
278 dynitem->dyn_iterate(dynitem, dentry, state, add_record);
279 }
280}
281
282static bool sysfs_iops_lookup(inode_t *dir, dentry_t *dentry)
283{
284 // if we get here, it means the expected dentry cannot be found in the dentry cache
285 // that means either it's a dynamic item, or the user is trying to access a file that doesn't exist
286
287 sysfs_dir_t *sysfs_dir = (sysfs_dir_t *) dir->private_data;
288
289 // if it's NULL, it implies that the dir must be the root directory /sys
290 MOS_ASSERT_X(sysfs_dir || dir == sysfs_sb->root->inode, "invalid sysfs entry, possibly a VFS bug");
291
292 if (!sysfs_dir)
293 return false; // sysfs root dir doesn't have any dynamic items
294
295 if (list_is_empty(head: &sysfs_dir->_dynamic_items))
296 return false;
297
298 list_node_foreach(item_node, &sysfs_dir->_dynamic_items)
299 {
300 sysfs_item_t *const dynitem = container_of(item_node, sysfs_item_t, list_node);
301 if (dynitem->dyn_lookup(dir, dentry))
302 return true;
303 }
304
305 return false;
306}
307
308static bool sysfs_iops_create(inode_t *dir, dentry_t *dentry, file_type_t type, file_perm_t perm)
309{
310 sysfs_dir_t *sysfs_dir = (sysfs_dir_t *) dir->private_data;
311 MOS_ASSERT_X(sysfs_dir || dir == sysfs_sb->root->inode, "invalid sysfs entry, possibly a VFS bug");
312
313 if (!sysfs_dir)
314 return false; // sysfs root dir doesn't have any dynamic items
315
316 if (list_is_empty(head: &sysfs_dir->_dynamic_items))
317 return false;
318
319 list_node_foreach(item_node, &sysfs_dir->_dynamic_items)
320 {
321 sysfs_item_t *const dynitem = container_of(item_node, sysfs_item_t, list_node);
322 if (dynitem->dyn_create(dir, dentry, type, perm))
323 return true;
324 }
325
326 return false;
327}
328
329static const inode_ops_t sysfs_dir_i_ops = {
330 .iterate_dir = sysfs_iops_iterate_dir,
331 .lookup = sysfs_iops_lookup,
332 .newfile = sysfs_iops_create,
333};
334
335static PtrResult<dentry_t> sysfs_fsop_mount(filesystem_t *fs, const char *dev, const char *options)
336{
337 MOS_ASSERT(fs == &fs_sysfs);
338 if (strcmp(str1: dev, str2: "none") != 0)
339 {
340 mos_warn("device not supported");
341 return -EINVAL;
342 }
343
344 if (options && strlen(str: options) != 0 && strcmp(str1: options, str2: "defaults") != 0)
345 {
346 mos_warn("options '%s' not supported", options);
347 return -ENOTSUP;
348 }
349
350 return sysfs_sb->root;
351}
352
353filesystem_t fs_sysfs = {
354 .name = "sysfs",
355 .mount = sysfs_fsop_mount,
356};
357
358static const file_perm_t sysfs_dir_perm = PERM_READ | PERM_EXEC; // r-xr-xr-x
359
360static void sysfs_do_register(sysfs_dir_t *sysfs_dir)
361{
362 inode_t *dir_i = inode_create(sb: sysfs_sb, ino: sysfs_get_ino(), type: FILE_TYPE_DIRECTORY);
363 dir_i->perm = sysfs_dir_perm;
364 dir_i->ops = &sysfs_dir_i_ops;
365 dir_i->file_ops = &sysfs_dir_file_ops;
366 dir_i->private_data = sysfs_dir; ///< for convenience
367
368 dentry_t *vfs_dir = dentry_get_from_parent(sb: sysfs_sb, parent: sysfs_sb->root, name: sysfs_dir->name);
369 dentry_attach(d: vfs_dir, inode: dir_i);
370 sysfs_dir->_dentry = vfs_dir;
371
372 for (size_t i = 0; i < sysfs_dir->num_items; i++)
373 sysfs_register_file(sysfs_dir, item: &sysfs_dir->items[i]);
374}
375
376inode_t *sysfs_create_inode(file_type_t type, void *data)
377{
378 inode_t *inode = inode_create(sb: sysfs_sb, ino: sysfs_get_ino(), type);
379 inode->private_data = data;
380 return inode;
381}
382
383void sysfs_register_file(sysfs_dir_t *sysfs_dir, sysfs_item_t *item)
384{
385 if (item->type == _SYSFS_INVALID)
386 return;
387
388 if (item->type == SYSFS_DYN)
389 {
390 MOS_ASSERT(item->dyn_iterate);
391 linked_list_init(list_node(item));
392 list_node_append(head: &sysfs_dir->_dynamic_items, list_node(item));
393 return;
394 }
395
396 inode_t *file_i = inode_create(sb: sysfs_sb, ino: sysfs_get_ino(), type: FILE_TYPE_REGULAR);
397 file_i->file_ops = &sysfs_file_ops;
398 file_i->private_data = item;
399 item->ino = file_i->ino;
400
401 switch (item->type)
402 {
403 case _SYSFS_INVALID: MOS_UNREACHABLE();
404 case SYSFS_DYN: MOS_UNREACHABLE();
405 case SYSFS_RO: file_i->perm |= PERM_READ; break;
406 case SYSFS_RW: file_i->perm |= PERM_READ | PERM_WRITE; break;
407 case SYSFS_WO: file_i->perm |= PERM_WRITE; break;
408 case SYSFS_MEM:
409 file_i->perm |= PERM_READ | PERM_WRITE | PERM_EXEC;
410 file_i->size = item->mem.size;
411 break;
412 }
413
414 if (unlikely(item->name.empty()))
415 pr_warn("no name specified for sysfs entry '%s'", sysfs_dir ? sysfs_dir->name.c_str() : "/");
416
417 dentry_t *const target_dentry = sysfs_dir ? sysfs_dir->_dentry : sysfs_sb->root;
418 MOS_ASSERT_X(target_dentry, "registering sysfs entry '%s' failed", item->name.c_str());
419 dentry_t *d = dentry_get_from_parent(sb: sysfs_sb, parent: target_dentry, name: item->name);
420 dentry_attach(d, inode: file_i);
421}
422
423MOS_INIT(VFS, register_sysfs)
424{
425 vfs_register_filesystem(fs: &fs_sysfs);
426
427 sysfs_sb = mos::create<superblock_t>();
428 sysfs_sb->fs = &fs_sysfs;
429 sysfs_sb->root = dentry_get_from_parent(sb: sysfs_sb, NULL, name: "");
430 inode_t *sysfs_root_inode = inode_create(sb: sysfs_sb, ino: sysfs_get_ino(), type: FILE_TYPE_DIRECTORY);
431 sysfs_root_inode->perm = PERM_READ | PERM_EXEC;
432 sysfs_root_inode->file_ops = &sysfs_dir_file_ops;
433 dentry_attach(d: sysfs_sb->root, inode: sysfs_root_inode);
434 sysfs_sb->root->inode->ops = &sysfs_dir_i_ops;
435}
436