1 /*
2 * Copyright (c) 2006-2023, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2023-07-04 zhkag first Version
9 */
10
11 #include <rtthread.h>
12 #include <rthw.h>
13 #include <dfs.h>
14 #include <dfs_fs.h>
15 #include <dfs_file.h>
16 #include <dfs_dentry.h>
17 #include <dfs_mnt.h>
18 #include "dfs_mqueue.h"
19
20 static rt_list_t _mqueue_file_list = RT_LIST_OBJECT_INIT(_mqueue_file_list);
21 struct rt_spinlock mqueue_lock;
22
dfs_mqueue_insert_after(rt_list_t * n)23 void dfs_mqueue_insert_after(rt_list_t *n) {
24 rt_spin_lock(&mqueue_lock);
25 rt_list_insert_after(&(_mqueue_file_list), n);
26 rt_spin_unlock(&mqueue_lock);
27 }
28
dfs_mqueue_lookup(const char * path,rt_size_t * size)29 struct mqueue_file *dfs_mqueue_lookup(const char *path, rt_size_t *size) {
30 struct mqueue_file *file;
31 rt_list_t *node;
32 rt_spin_lock(&mqueue_lock);
33 rt_list_for_each(node, &_mqueue_file_list) {
34 file = rt_list_entry(node, struct mqueue_file, list);
35
36 if (rt_strncmp(file->name, path, RT_NAME_MAX) == 0) {
37 *size = file->size;
38 rt_spin_unlock(&mqueue_lock);
39 return file;
40 }
41 }
42 rt_spin_unlock(&mqueue_lock);
43 return RT_NULL;
44 }
45
dfs_mqueue_mount(struct dfs_mnt * mnt,unsigned long rwflag,const void * data)46 int dfs_mqueue_mount(struct dfs_mnt *mnt, unsigned long rwflag, const void *data) {
47 return RT_EOK;
48 }
49
dfs_mqueue_umount(struct dfs_mnt * mnt)50 int dfs_mqueue_umount(struct dfs_mnt *mnt) {
51 return RT_EOK;
52 }
53
dfs_mqueue_statfs(struct dfs_mnt * mnt,struct statfs * buf)54 int dfs_mqueue_statfs(struct dfs_mnt *mnt, struct statfs *buf) {
55 return RT_EOK;
56 }
57
dfs_mqueue_close(struct dfs_file * file)58 int dfs_mqueue_close(struct dfs_file *file) {
59 return RT_EOK;
60 }
61
dfs_mqueue_open(struct dfs_file * file)62 int dfs_mqueue_open(struct dfs_file *file) {
63 return 0;
64 }
65
dfs_mqueue_stat(struct dfs_dentry * dentry,struct stat * st)66 int dfs_mqueue_stat(struct dfs_dentry *dentry, struct stat *st) {
67 struct dfs_vnode *vnode = RT_NULL;
68 if (dentry && dentry->vnode) {
69 vnode = dentry->vnode;
70 st->st_dev = 0;
71 st->st_gid = vnode->gid;
72 st->st_uid = vnode->uid;
73 st->st_ino = 0;
74 st->st_mode = vnode->mode;
75 st->st_nlink = vnode->nlink;
76 st->st_size = vnode->size;
77 st->st_mtim.tv_nsec = vnode->mtime.tv_nsec;
78 st->st_mtim.tv_sec = vnode->mtime.tv_sec;
79 st->st_ctim.tv_nsec = vnode->ctime.tv_nsec;
80 st->st_ctim.tv_sec = vnode->ctime.tv_sec;
81 st->st_atim.tv_nsec = vnode->atime.tv_nsec;
82 st->st_atim.tv_sec = vnode->atime.tv_sec;
83 }
84 return RT_EOK;
85 }
86
dfs_mqueue_getdents(struct dfs_file * file,struct dirent * dirp,uint32_t count)87 int dfs_mqueue_getdents(struct dfs_file *file, struct dirent *dirp, uint32_t count) {
88 rt_size_t index, end;
89 struct dirent *d;
90 count = (count / sizeof(struct dirent));
91 end = file->fpos + count;
92 index = 0;
93 count = 0;
94 struct mqueue_file *mq_file;
95 rt_list_t *node;
96 rt_spin_lock(&mqueue_lock);
97 rt_list_for_each(node, &_mqueue_file_list) {
98 if (index >= (rt_size_t)file->fpos) {
99 mq_file = rt_list_entry(node, struct mqueue_file, list);
100 d = dirp + count;
101 d->d_namlen = RT_NAME_MAX;
102 d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
103 rt_strncpy(d->d_name, mq_file->name, RT_NAME_MAX);
104 count += 1;
105 file->fpos += 1;
106 }
107 index += 1;
108 if (index >= end) {
109 break;
110 }
111 }
112 rt_spin_unlock(&mqueue_lock);
113 return count * sizeof(struct dirent);
114 }
115
dfs_mqueue_unlink(struct dfs_dentry * dentry)116 int dfs_mqueue_unlink(struct dfs_dentry *dentry) {
117 rt_size_t size;
118 struct mqueue_file *mq_file;
119 mq_file = dfs_mqueue_lookup(dentry->pathname + 1, &size);
120 if (mq_file == RT_NULL)
121 return -ENOENT;
122 rt_list_remove(&(mq_file->list));
123 if (mq_file->data != RT_NULL)
124 rt_mq_delete((rt_mq_t)mq_file->data);
125 rt_free(mq_file);
126 return RT_EOK;
127 }
128
dfs_mqueue_create_vnode(struct dfs_dentry * dentry,int type,mode_t mode)129 static struct dfs_vnode *dfs_mqueue_create_vnode(struct dfs_dentry *dentry, int type, mode_t mode) {
130 struct dfs_vnode *vnode = RT_NULL;
131 rt_size_t size;
132 struct mqueue_file *mq_file;
133
134 if (dentry == NULL || dentry->mnt == NULL) {
135 return NULL;
136 }
137
138 vnode = dfs_vnode_create();
139 if (vnode) {
140 mq_file = dfs_mqueue_lookup(dentry->pathname + 1, &size);
141 if (mq_file == RT_NULL) {
142 mq_file = (struct mqueue_file *)rt_malloc(sizeof(struct mqueue_file));
143 if (mq_file == RT_NULL) {
144 return NULL;
145 }
146 mq_file->msg_size = 8192;
147 mq_file->max_msgs = 10;
148 strncpy(mq_file->name, dentry->pathname + 1, RT_NAME_MAX - 1);
149 dfs_mqueue_insert_after(&(mq_file->list));
150 }
151
152 vnode->mode = S_IFREG | (S_IRWXU | S_IRWXG | S_IRWXO);
153 vnode->type = FT_REGULAR;
154 rt_mq_t mq = rt_mq_create(dentry->pathname + 1, mq_file->msg_size, mq_file->max_msgs,
155 RT_IPC_FLAG_FIFO);
156 mq_file->data = (void *)mq;
157 vnode->data = mq_file;
158 vnode->size = 0;
159 }
160 return vnode;
161 }
162
dfs_mqueue_free_vnode(struct dfs_vnode * vnode)163 static int dfs_mqueue_free_vnode(struct dfs_vnode *vnode) {
164 /* nothing to be freed */
165 if (vnode && vnode->ref_count <= 1) {
166 vnode->data = NULL;
167 }
168 return 0;
169 }
170
171 static const struct dfs_file_ops _mqueue_fops = {
172 .open = dfs_mqueue_open,
173 .close = dfs_mqueue_close,
174 .getdents = dfs_mqueue_getdents,
175 };
176
_dfs_mqueue_lookup(struct dfs_dentry * dentry)177 struct dfs_vnode *_dfs_mqueue_lookup(struct dfs_dentry *dentry) {
178 struct dfs_vnode *vnode = RT_NULL;
179 rt_size_t size;
180 // struct tmpfs_sb *superblock;
181 struct mqueue_file *mq_file;
182
183 if (dentry == NULL || dentry->mnt == NULL) {
184 return NULL;
185 }
186
187 if (dentry->pathname[0] == '/' && dentry->pathname[1] == '\0') {
188 }
189
190 mq_file = dfs_mqueue_lookup(dentry->pathname + 1, &size);
191
192 vnode = dfs_vnode_create();
193 if (mq_file && mq_file->data) {
194 vnode->mode = S_IFREG | (S_IRWXU | S_IRWXG | S_IRWXO);
195 vnode->type = FT_REGULAR;
196 vnode->mnt = dentry->mnt;
197 vnode->data = mq_file;
198 vnode->size = mq_file->size;
199 } else {
200 vnode->size = 0;
201 vnode->nlink = 1;
202 vnode->fops = &_mqueue_fops;
203 vnode->mnt = dentry->mnt;
204 vnode->type = FT_DIRECTORY;
205 vnode->mode = S_IFDIR | (S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
206 }
207 return vnode;
208 }
209
210 static const struct dfs_filesystem_ops _mqueue_ops = {
211 .name = "mqueue",
212 .flags = DFS_FS_FLAG_DEFAULT,
213 .default_fops = &_mqueue_fops,
214
215 .mount = dfs_mqueue_mount,
216 .umount = dfs_mqueue_umount,
217 .statfs = dfs_mqueue_statfs,
218
219 .unlink = dfs_mqueue_unlink,
220 .stat = dfs_mqueue_stat,
221
222 .lookup = _dfs_mqueue_lookup,
223 .create_vnode = dfs_mqueue_create_vnode,
224 .free_vnode = dfs_mqueue_free_vnode
225 };
226
227 static struct dfs_filesystem_type _mqueue = {
228 .fs_ops = &_mqueue_ops,
229 };
230
dfs_mqueue_init(void)231 int dfs_mqueue_init(void) {
232 /* register mqueue file system */
233 dfs_register(&_mqueue);
234 mkdir("/dev/mqueue", 0x777);
235 if (dfs_mount(RT_NULL, "/dev/mqueue", "mqueue", 0, 0) != 0)
236 {
237 rt_kprintf("Dir /dev/mqueue mount failed!\n");
238 }
239 return 0;
240 }
241 INIT_ENV_EXPORT(dfs_mqueue_init);
242