SayoriOS 0.3.3

NatSuki.c
См. документацию.
1
10 #include <lib/string.h>
11 #include <io/ports.h>
12 #include "drv/vfs_new.h"
13 #include "io/serial_port.h"
14 #include "mem/vmm.h"
15 #include "lib/split.h"
16 #include "io/tty.h"
17
18 fs_node_t *nat_root = 0;
19 bool __milla_b_init = false;
20 char* __milla_null = "null";
21 char* __milla_buffer = 0;
22 char __milla_login[256] = "SayoriOS";
23 char __milla_passwd[256] = "NatSuki";
24 int __milla_return_code = 0;
25
26 void __milla_setLogin(char* login){
27 memset(__milla_login,0,256);
28 memcpy((void*)__milla_login, (void*)login, strlen(login));
29 qemu_log("[NatSuki] New login: %s",__milla_login);
30 }
31
32 void __milla_setPasswd(char* passwd){
33 memset(__milla_passwd,0,256);
34 memcpy((void*)__milla_passwd, (void*)passwd, strlen(passwd));
35 qemu_log("[NatSuki] New password: %s",__milla_passwd);
36 }
37
38 int __milla_getCode(){
39 return __milla_return_code;
40 }
41
42 /*********************************/
43
44
48 void __milla_sendcmd(char* msg){
49 if (!__milla_b_init)
50 return;
51
52 __com_formatString(PORT_COM2,"%s |$MC#|",msg);
53 }
54
58 char* __milla_getcmd(){
59 if (!__milla_b_init){return __milla_null;}
60 char tmp = 'S';
61 size_t inx = 0;
62 memset(__milla_buffer,0,256);
63 for(;;) {
64 if (inx >= 128){
65 __milla_buffer[inx+1] = 0;
66 break;
67 }
68 tmp = serial_readchar(PORT_COM2);
69 if ((int) tmp == 10 && inx == 0) continue;
70 //qemu_log("Write %d / 128",inx);
71 //qemu_log("\n (%d = %c) \n",(int) tmp,tmp);
72 if ((int) tmp == 10){
73 __milla_buffer[inx+1] = 0;
74 break;
75 }
76 //tty_printf("%c", tmp);
77 __milla_buffer[inx] = tmp;
78 inx++;
79 }
80 //qemu_log("Milla: %s",__milla_buffer);
81 //tty_printf("Milla: %s\n",__milla_buffer);
82 return __milla_buffer;
83 }
84
85 int __milla_getSizeFile(char* path){
86 if (!__milla_b_init){return 0;}
87 __com_formatString(PORT_COM2,"SIZE %s |$MC#|",path);
88 int answer = atoi(__milla_getcmd());
89 if (answer < 0){
90 qemu_log("[Milla] [getSizeFile] ERR! Return %d:%s",answer,__milla_buffer);
91 return 0;
92 }
93 return answer;
94 }
95
96
97 char* __milla_getDiskInfo_Name(){
98 if (!__milla_b_init){return 0;}
99 __com_formatString(PORT_COM2,"DISKNAME |$MC#|");
100 __milla_getcmd();
101
102 return __milla_buffer;
103 }
104
105
106 int __milla_getDiskInfo_Free(){
107 if (!__milla_b_init){return 0;}
108 __com_formatString(PORT_COM2,"DISKSIZE_FREE |$MC#|");
109 int answer = atoi(__milla_getcmd());
110 if (answer < 0){
111 qemu_log("[Milla] [getDiskInfo_Free] ERR! Return %d:%s",answer,__milla_buffer);
112 return 0;
113 }
114 return answer;
115 }
116
117
118 int __milla_getDiskInfo_Use(){
119 if (!__milla_b_init){return 0;}
120 __com_formatString(PORT_COM2,"DISKSIZE_USE |$MC#|");
121 int answer = atoi(__milla_getcmd());
122 if (answer < 0){
123 qemu_log("[Milla] [getDiskInfo_Use] ERR! Return %d:%s",answer,__milla_buffer);
124 return 0;
125 }
126 return answer;
127 }
128
129
130 int __milla_getDiskInfo_All(){
131 if (!__milla_b_init){return 0;}
132 __com_formatString(PORT_COM2,"DISKSIZE_ALL |$MC#|");
133 int answer = atoi(__milla_getcmd());
134 if (answer < 0){
135 qemu_log("[Milla] [getDiskInfo_All] ERR! Return %d:%s",answer,__milla_buffer);
136 return 0;
137 }
138 return answer;
139 }
140
141
145 int __milla_cleanState(){
146 if (!__milla_b_init){return 0;}
147 __milla_sendcmd("CLEAN");
148 int answer = strcmp(__milla_getcmd(),"CLEAN");
149 if (answer != 0){
150 for (size_t i = 0;i < 5;i++){
151 __milla_sendcmd("CLEAN");
152 answer = strcmp(__milla_getcmd(),"CLEAN");
153 if (answer == 0){
154 break;
155 }
156 }
157 }
158 if (answer == 0){
159 qemu_log("[Milla] [Clean] OK! Return %d:%s",answer,__milla_buffer);
160 return 1;
161 } else {
162 qemu_log("[Milla] [Clean] ERR! Return %d:%s",answer,__milla_buffer);
163 return 0;
164 }
165 }
166
167 char* __milla_getFile(const char *path) {
168 if (!__milla_b_init){return __milla_null;}
169 __com_formatString(PORT_COM2,"READ %s |$MC#|",path);
170 int answer = atoi(__milla_getcmd());
171 if (answer < 0){
172 qemu_log("[Milla] [getFile] ERR! Return %d:%s",answer,__milla_buffer);
173 return __milla_null;
174 } else if (answer == 0){
175 qemu_log("[Milla] [getFile] ERR! Return %d:%s",answer,__milla_buffer);
176 return __milla_null;
177 }
178 qemu_log("[Milla] [getFile] OK! Return %d:%s",answer,__milla_buffer);
179 __milla_sendcmd("READ GET");
180 char tmp = 'S';
181 size_t inx = 0;
182 char* buf = (char*)kmalloc(sizeof(char*) * answer);
183 memset(buf,0,answer);
184 bool st1 = false;
185 for(;;) {
186 if (inx >= answer)break;
187 tmp = serial_readchar_timeout(PORT_COM2,10000,false);
188 if (tmp == 0xFFFFFFFF && !st1){
189 //qemu_log("SKIP 0xFFFFFFFF");
190 continue;
191 }
192 if (tmp != 0xFFFFFFFF && !st1) st1 = true;
193
194 buf[inx] = tmp;
195 inx++;
196 }
197 return buf;
198 }
199
200 int __milla_writeFile(char* path, char* data){
201 if (!__milla_b_init){return -9999;}
202 __com_formatString(PORT_COM2,"WRITE %s |$MC#|",path);
203 int answer = atoi(__milla_getcmd());
204 if (answer != 1){
205 qemu_log("[Milla] [writeFile] ERR1! Return %d:%s",answer,__milla_buffer);
206 return -1;
207 }
208 __com_formatString(PORT_COM2,"WRITE %d |$MC#|",strlen(data));
209 answer = atoi(__milla_getcmd());
210 if (answer != 1){
211 qemu_log("[Milla] [writeFile] ERR2! Return %d:%s",answer,__milla_buffer);
212 return -2;
213 }
214 __com_formatString(PORT_COM2,"%s",data);
215 answer = atoi(__milla_getcmd());
216 if (answer != strlen(data)){
217 qemu_log("[Milla] [writeFile] ERR3! Return %d:%s",answer,__milla_buffer);
218 return -3;
219 }
220 qemu_log("[Milla] [writeFile] OK! %d:%s",strlen(data),data);
221 return answer;
222 }
223
224 int __milla_delete(char* path){
225 if (!__milla_b_init){return -9999;}
226 __com_formatString(PORT_COM2,"DEL %s |$MC#|",path);
227 int answer = atoi(__milla_getcmd());
228
229 return answer;
230 }
231
232 int __milla_mkdir(char* path){
233 if (!__milla_b_init){return -9999;}
234 __com_formatString(PORT_COM2,"MKDIR %s |$MC#|",path);
235 int answer = atoi(__milla_getcmd());
236
237 return answer;
238 }
239
240 size_t __milla_findID(char* path,char* type){
241 if (!__milla_b_init){return -9999;}
242 __com_formatString(PORT_COM2,"FIND %s %s |$MC#|",type,path);
243 return atoi(__milla_getcmd());
244 }
245
246
247 size_t __milla_isDir(size_t inx){
248 if (!__milla_b_init){return -9999;}
249 __com_formatString(PORT_COM2,"ISDIR %d |$MC#|",inx);
250 return atoi(__milla_getcmd());
251 }
252
253 size_t __milla_isFile(size_t inx){
254 if (!__milla_b_init){return -9999;}
255 __com_formatString(PORT_COM2,"ISFILE %d |$MC#|",inx);
256 return atoi(__milla_getcmd());
257 }
258
259 char* __milla_getRootID(size_t inx){
260 if (!__milla_b_init){return __milla_null;}
261 __com_formatString(PORT_COM2,"ROOT %d |$MC#|",inx);
262 return (__milla_getcmd());
263 }
264
265
266 int __milla_touch(char* path){
267 if (!__milla_b_init){return -9999;}
268 __com_formatString(PORT_COM2,"TOUCH %s |$MC#|",path);
269 int answer = atoi(__milla_getcmd());
270
271 return answer;
272 }
273
274
275
276
277 char* __milla_getList(char* path){
278 if (!__milla_b_init){return __milla_null;}
279 __com_formatString(PORT_COM1,"\n< LIST %s |$MC#|\n",path);
280 __com_formatString(PORT_COM2,"LIST %s |$MC#|",path);
281 int answer = atoi(__milla_getcmd());
282 __com_formatString(PORT_COM1,"> %d\n",answer);
283 if (answer < 0){
284 qemu_log("[Milla] [getFile] ERR! Return %d:%s",answer,__milla_buffer);
285 return __milla_null;
286 } else if (answer == 0){
287 qemu_log("[Milla] [getFile] OK! Folder EMPTY Return %d:%s",answer,__milla_buffer);
288 return __milla_null;
289 }
290
291 qemu_log("[Milla] [getFile] OK! Return %d:%s",answer,__milla_buffer);
292 __com_formatString(PORT_COM1,"\n> LIST GET\n");
293 __com_formatString(PORT_COM2,"LIST GET|$MC#|");
294 //__milla_sendcmd("LIST GET");
295 char tmp = 'S';
296 size_t inx = 0;
297 char* buf = (char*)kmalloc(sizeof(char*) * answer);
298 memset(buf,0,answer);
299 bool st1 = false;
300 for(;;) {
301 if (inx >= answer)break;
302
303 tmp = serial_readchar_timeout(PORT_COM2,10000,false);
304 if (tmp == 0xFFFFFFFF && !st1){
305 //qemu_log("SKIP 0xFFFFFFFF");
306 continue;
307 }
308 if (tmp != 0xFFFFFFFF && !st1) st1 = true;
309
310 buf[inx] = tmp;
311 inx++;
312 }
313 __com_formatString(PORT_COM1,"< %s\n",buf);
314 return buf;
315 }
316
317 size_t __milla_getCountFiles(char* path){
318 if (!__milla_b_init){return -9999;}
319 __com_formatString(PORT_COM2,"COUNT %s |$MC#|",path);
320 return atoi(__milla_getcmd());
321 }
322
323
327 int __milla_init(){
328 __com_setInit(2,1);
329 if (!__milla_b_init){
330 int cominit = __com_init(PORT_COM2);
331 if (cominit == 1){
332 __milla_return_code = 1;
333 return -1; // Не удалось выполнить инициализацию
334 }
335 qemu_log("[Milla] Step 1 PASSED");
336 // Подгрузим буфер и отчистим его, если там есть что-то
337 __milla_buffer = (char*)kmalloc(sizeof(char*) * 256);
338 memset(__milla_buffer,0,256);
339 __milla_b_init = true;
340 __com_formatString(PORT_COM2,"LOGIN %s %s|$MC#|",__milla_login,__milla_passwd);
341 int answer = atoi(__milla_getcmd());
342 if (answer != 1){
343 qemu_log("[Milla] ERROR AUTH %d (%s)",answer,__milla_buffer);
344 __milla_b_init = false;
345 __milla_return_code = 2;
346 return -2; // Не удалось выполнить инициализацию
347 }
348 cominit = __milla_cleanState();
349 qemu_log("[Milla] Step 2 PASSED");
350 if (cominit != 1){
351 qemu_log("[Milla] Step 3 ERROR");
352 __milla_return_code = 3;
353 return -3; // Не удалось отчистить буфер
354 }
355 qemu_log("[Milla] Step 3 PASSED");
356 }
357 __milla_b_init = true;
358 __milla_return_code = 0;
359 return 0;
360 }
361
362
363 void __milla_destroy(){
364 kfree(__milla_buffer);
365 }
366
367 /*********************************/
368
369
370
371
372
373
374
375
376
384 char* nat_readChar(uint32_t node){
385 qemu_log("[NatSuki] [nat_readChar] ");
386 return 0;
387 }
388
399 uint32_t nat_read(uint32_t node, size_t offset, size_t size, void *buffer){
400 if (!__milla_b_init) return 0;
401
402 substr(buffer,(void*)__milla_getFile(__milla_getRootID(node)),offset,size);
403
404 //memcpy(buffer, __milla_getFile(__milla_getRootID(node)), size);
405 qemu_log("[NatSuki] [nat_read] [Offset:%d] [Size:%d] Node: %d | Data: %d",offset,size,strlen(buffer));
406 return strlen(buffer);
407 }
408
419 uint32_t nat_write(uint32_t node, size_t offset, size_t size, void *buffer){
420 if (!__milla_b_init) return 0;
421 qemu_log("[NatSuki] [nat_write] ");
422 return -2;
423 }
424
432 size_t nat_getLengthFile(int node){
433 if (!__milla_b_init) return 0;
434 //qemu_log("[NatSuki] [nat_getLengthFile] Node: %d",node);
435
436 return __milla_getSizeFile(__milla_getRootID(node));
437 }
438
446 size_t nat_getOffsetFile(int node){
447 qemu_log("[NatSuki] [nat_getOffsetFile] ");
448 return 0;
449 }
450
458 int32_t nat_findFile(char* filename){
459 if (!__milla_b_init) return -1;
460 //qemu_log("[NatSuki] [nat_findFile] %s",filename);
461 return __milla_findID(filename,"FILE");
462 }
463
471 int32_t nat_findDir(char* path){
472 if (!__milla_b_init) return -1;
473 //qemu_log("[NatSuki] [nat_findDir] %s",path);
474
475 return __milla_findID(path,"DIR");
476 }
477
481 size_t nat_countElemFolder(char* path){
482 if (!__milla_b_init) return 0;
483 //qemu_log("[NatSuki] [nat_countElemFolder] %s",path);
484 return __milla_getCountFiles(path);
485 }
486
490 struct dirent* nat_list(char* path){
491 size_t inxDir = nat_findDir(path);
492 if (inxDir < 0){
493 return 0;
494 }
495
496
497
498 qemu_log("[NatSuki] [nat_list] %s",path);
499 char* listt = __milla_getList(path);
500 //tty_printf("\n%s\n",listt);
501
502 uint32_t _m_d1 = str_cdsp(listt,"\n");
503 char* _m_d[256] = {0};
504 str_split(listt,_m_d,"\n");
505 uint32_t _m_d2 = 0;
506
507 char* _m_s[256] = {0};
508 size_t inxFile = 0;
509 tty_printf("Найдено файлов и папок: %d\n",_m_d1);
510 struct dirent* testFS = kcalloc(_m_d1, sizeof(struct dirent));
511 if (_m_d1 == 0){
512 return testFS;
513 }
514 for(size_t ind = 0; ind < _m_d1; ind++){
515 _m_d2 = str_cdsp(_m_d[ind],"::");
516 if (_m_d2 < 1) continue;
517 memset(_m_s,0,256);
518 str_split(_m_d[ind],_m_s,"::");
519 testFS[inxFile].type = ((strcmpn(_m_s[0], "file")?FS_FILE:FS_DIRECTORY));
520 testFS[inxFile].ino = inxFile;
521 testFS[inxFile].next = inxFile+1;
522 testFS[inxFile].length = (atoi(_m_s[4]));
523 strcpy(testFS[inxFile].name, _m_s[1]);
524 inxFile++;
525 qemu_log("[Milla] [%s] %s (%d b.) Date: %s Owner: %s",_m_s[0],_m_s[1],(atoi(_m_s[4])),_m_s[3],_m_s[5]);
526 }
527 testFS[inxFile].next = 0;
528 kfree(listt);
529 kfree((void*)_m_d);
530 kfree((void*)_m_s);
531 kfree((void*)_m_d1);
532 kfree((void*)_m_d2);
533 return testFS;
534 }
535
543 size_t nat_diskUsed(int node){
544 qemu_log("[NatSuki] [nat_diskUsed] ");
545 return 2;
546 }
547
555 size_t nat_diskSpace(int node){
556 qemu_log("[NatSuki] [nat_diskSpace] ");
557 return 0;
558 }
559
567 size_t nat_diskSize(int node){
568 qemu_log("[NatSuki] [nat_diskSize] ");
569 return 1;
570 }
571
579 char* nat_getDevName(int node){
580 qemu_log("[NatSuki] [nat_getDevName] ");
581 if (!__milla_b_init) return "0000-0000";
582 return nat_root->devName;
583 }
584
585 void nat_dirfree(struct dirent* ptr) {
586 qemu_log("[NatSuki] [nat_dirfree] ");
587 }
588
589 bool isInitNatSuki(){
590 return __milla_b_init;
591 }
592
600 fs_node_t *NatSuki_initrd(uint32_t location){
601 qemu_log("[NatSuki] [Init] loc: %x | state: %d",location,__milla_b_init);
602
603 nat_root = (fs_node_t*)kmalloc(sizeof(fs_node_t));
604 if (!__milla_b_init){
605 int cominit = __milla_init();
606
607 qemu_log("NatSuki -> %d",cominit);
608 if (cominit != 0){
609 strcpy(nat_root->name, "/nat/");
610 strcpy(nat_root->devName, "0000-0000");
611 return nat_root; // Не удалось выполнить инициализацию
612 }
613 __milla_b_init = true;
614 }
615
616 strcpy(nat_root->name, "/nat/");
617 strcpy(nat_root->devName, __milla_getDiskInfo_Name());
618 nat_root->mask = nat_root->uid = nat_root->gid = nat_root->inode = nat_root->length = 0;
619 nat_root->flags = FS_DIRECTORY;
620 nat_root->open = 0;
621 nat_root->close = 0;
622 nat_root->findFile = (findFile_type_t) &nat_findFile;
623 nat_root->findDir = (findFile_type_t) &nat_findDir;
624 nat_root->getLengthFile = &nat_getLengthFile;
625 nat_root->getOffsetFile = &nat_getOffsetFile;
626 nat_root->list = (list_type_t) &nat_list;
627 nat_root->ptr = 0;
628 nat_root->impl = 0;
629 nat_root->readChar = &nat_readChar;
630 nat_root->read = &nat_read;
631 nat_root->write = (write_type_t) &nat_write;
632 nat_root->diskUsed = &nat_diskUsed;
633 nat_root->diskSpace = &nat_diskSpace;
634 nat_root->diskSize = &nat_diskSize;
635 nat_root->getDevName = &nat_getDevName;
636 nat_root->getCountElemFolder = &nat_countElemFolder;
637 nat_root->getListElem = (dirlist_type_t) &nat_list;
638 nat_root->unlistElem = &nat_dirfree;
639
640 return nat_root;
641 }
642
nat_findDir
int32_t nat_findDir(char *path)
[SEFS] Поиск папки на устройстве
Definition: NatSuki.c:471
__milla_login
char __milla_login[256]
Логин для авторизации
Definition: NatSuki.c:22
nat_list
struct dirent * nat_list(char *path)
[SEFS] Выводит список файлов
Definition: NatSuki.c:490
nat_getOffsetFile
size_t nat_getOffsetFile(int node)
[SEFS] Получить отступ в файловой системе у файла
Definition: NatSuki.c:446
nat_root
fs_node_t * nat_root
Ссылка на виртуальную фс
Definition: NatSuki.c:18
nat_getLengthFile
size_t nat_getLengthFile(int node)
[SEFS] Получить размер файла (поиск по индексу)
Definition: NatSuki.c:432
__milla_return_code
int __milla_return_code
Код ошибки
Definition: NatSuki.c:24
nat_diskUsed
size_t nat_diskUsed(int node)
[SEFS] Количество используемого места устройства
Definition: NatSuki.c:543
__milla_init
int __milla_init()
Инициализация проекта Милла
Definition: NatSuki.c:327
nat_findFile
int32_t nat_findFile(char *filename)
[SEFS] Поиск файла на устройстве
Definition: NatSuki.c:458
__milla_sendcmd
void __milla_sendcmd(char *msg)
[Milla] Отправка пакета
Definition: NatSuki.c:48
NatSuki_initrd
fs_node_t * NatSuki_initrd(uint32_t location)
[SEFS] Инициализация Sayori Easy File System
Definition: NatSuki.c:600
__milla_getcmd
char * __milla_getcmd()
[Milla] Чтение пакета
Definition: NatSuki.c:58
nat_countElemFolder
size_t nat_countElemFolder(char *path)
[SEFS] Считает количество элементов в папке
Definition: NatSuki.c:481
__milla_null
char * __milla_null
Ответ, если Milla не готовa.
Definition: NatSuki.c:20
nat_diskSpace
size_t nat_diskSpace(int node)
[SEFS] Количество свободного места устройства
Definition: NatSuki.c:555
__milla_passwd
char __milla_passwd[256]
Пароль для авторизации
Definition: NatSuki.c:23
__milla_buffer
char * __milla_buffer
Буфер
Definition: NatSuki.c:21
__milla_cleanState
int __milla_cleanState()
Сбрасывает состояние Milla.
Definition: NatSuki.c:145
nat_diskSize
size_t nat_diskSize(int node)
[SEFS] Количество всего места устройства
Definition: NatSuki.c:567
nat_read
uint32_t nat_read(uint32_t node, size_t offset, size_t size, void *buffer)
[SEFS] Чтение файла
Definition: NatSuki.c:399
nat_getDevName
char * nat_getDevName(int node)
[SEFS] Получение имени устройства
Definition: NatSuki.c:579
__milla_b_init
bool __milla_b_init
Milla готова к работе?
Definition: NatSuki.c:19
nat_write
uint32_t nat_write(uint32_t node, size_t offset, size_t size, void *buffer)
[SEFS] запись в файл
Definition: NatSuki.c:419
nat_readChar
char * nat_readChar(uint32_t node)
[SEFS] Полное чтение файла
Definition: NatSuki.c:384
strlen
size_t strlen(const char *str)
Возращает длину строки
Definition: string.c:88
strcmp
int strcmp(const char *s1, const char *s2)
Сравнение строк
Definition: string.c:253
atoi
uint32_t atoi(const char s[])
Превращает строку в число
Definition: string.c:565
strcmpn
bool strcmpn(const char *str1, const char *str2)
Сравнение строк
Definition: string.c:270
memset
void * memset(void *ptr, char value, size_t num)
Заполнение массива указанными символами
Definition: string.c:203
memcpy
void * memcpy(void *restrict destination, const void *restrict source, size_t n)
Копирование непересекающихся массивов используя SSE.
Definition: string.c:173
substr
void substr(char *restrict dest, const char *restrict source, int from, int length)
Вырезает и возвращает подстроку из строки
Definition: string.c:492
strcpy
int strcpy(char *dest, const char *src)
Копирование строк
Definition: string.c:282
str_cdsp
uint32_t str_cdsp(const char *a_str, const char *del)
Функция отладки
Definition: split.c:22
str_split
void str_split(const char a_str[], char *out[], char *del)
Функция для деления строк
Definition: split.c:40
dirent
Согласно POSIX, один из них возвращается вызовом readdir.
Definition: vfs_new.h:77
dirent::type
uint8_t type
Тип файла
Definition: vfs_new.h:80
dirent::next
uint8_t next
Следующая позиция
Definition: vfs_new.h:81
dirent::name
char name[128]
Имя файла
Definition: vfs_new.h:78
dirent::ino
uint32_t ino
Номер inode. Требеся для POSIX.
Definition: vfs_new.h:79
dirent::length
size_t length
Размер файла
Definition: vfs_new.h:82
fs_node
Definition: vfs_new.h:39
fs_node::diskSpace
getDeviceSize_type_t diskSpace
Сколько свободно места
Definition: vfs_new.h:67
fs_node::read
read_type_t read
Функция FS - Чтение файла с указанием параметров
Definition: vfs_new.h:51
fs_node::getOffsetFile
getLengthFile_type_t getOffsetFile
Функция FS - Функция для получения позиции файла (отступ)
Definition: vfs_new.h:61
fs_node::ptr
struct fs_node * ptr
Используется для точек монтирования и символических ссылок.
Definition: vfs_new.h:70
fs_node::getListElem
dirlist_type_t getListElem
Функция FS - Функция для получения списка файлов
Definition: vfs_new.h:62
fs_node::getDevName
charintData_type_t getDevName
Функция для получения имени устройства
Definition: vfs_new.h:64
fs_node::write
write_type_t write
Функция FS - Запись в файл
Definition: vfs_new.h:52
fs_node::readChar
readChar_type_t readChar
Функция FS - Полное чтение файла
Definition: vfs_new.h:50
fs_node::getCountElemFolder
countElemFolder_type_t getCountElemFolder
Функция FS - Функция для получения количества файлов в папке
Definition: vfs_new.h:56
fs_node::uid
uint32_t uid
Пользователь, владеющий файлом.
Definition: vfs_new.h:44
fs_node::open
open_type_t open
Функция FS - Функция для открытия файла (не исп)
Definition: vfs_new.h:53
fs_node::getLengthFile
getLengthFile_type_t getLengthFile
Функция FS - Функция для получения размера файла
Definition: vfs_new.h:60
fs_node::diskUsed
getDeviceSize_type_t diskUsed
Сколько использовано места
Definition: vfs_new.h:66
fs_node::impl
uint32_t impl
Номер, зависящий от реализации.
Definition: vfs_new.h:49
fs_node::flags
uint32_t flags
Включает тип нода. Смотрите определение #defines, приведенное выше.
Definition: vfs_new.h:46
fs_node::inode
uint32_t inode
Зависит от устройства, позволяет файловой системе идентифицировать файлы.
Definition: vfs_new.h:47
fs_node::findDir
findFile_type_t findDir
Функция FS - Функция для поиска файла
Definition: vfs_new.h:58
fs_node::name
char name[128]
Имя файла.
Definition: vfs_new.h:40
fs_node::list
list_type_t list
Список
Definition: vfs_new.h:69
fs_node::gid
uint32_t gid
Группа, владеющая файлом.
Definition: vfs_new.h:45
fs_node::close
close_type_t close
Функция FS - Функция для закрытия файла (не исп)
Definition: vfs_new.h:54
fs_node::devName
char devName[512]
Имя устройства
Definition: vfs_new.h:65
fs_node::findFile
findFile_type_t findFile
Функция FS - Функция для поиска файла
Definition: vfs_new.h:57
fs_node::mask
uint32_t mask
Маска прав доступа.
Definition: vfs_new.h:43
fs_node::diskSize
getDeviceSize_type_t diskSize
Размер диска
Definition: vfs_new.h:68
fs_node::length
uint32_t length
Размер файла в байтах.
Definition: vfs_new.h:48