Add back functions for converting M to kdirents.
[akaros.git] / kern / src / ns / convM2kdirent.c
1
2 #include <vfs.h>
3 #include <kfs.h>
4 #include <slab.h>
5 #include <kmalloc.h>
6 #include <kref.h>
7 #include <string.h>
8 #include <stdio.h>
9 #include <assert.h>
10 #include <error.h>
11 #include <cpio.h>
12 #include <pmap.h>
13 #include <smp.h>
14 #include <ip.h>
15
16 /* Special akaros edition. */
17 /* akaros does not (yet) pass as much info as plan 9 does,
18  * and it still has stuff I'm not happy about like an inode number.
19  */
20 #if 0
21 struct kdirent {
22         __ino64_t d_ino;                        /* inod
23                                                                    e number */
24         __off64_t d_off;                        /* offs
25                                                                    et to the next dirent */
26         unsigned short d_reclen;        /* length of th
27                                                                    is record */
28         unsigned char d_type;
29         char d_name[MAX_FILENAME_SZ + 1];       /* filename */
30 } __attribute__ ((aligned(8)));
31
32 #endif
33
34 unsigned int convM2kdirent(uint8_t * buf, unsigned int nbuf, struct kdirent *kd)
35 {
36         uint8_t *p, *ebuf;
37         char *sv[4];
38         int i, ns;
39         uint32_t junk;
40         printd("%s >>>>>>>>>nbuf %d STATFIXLEN %d\n", __func__, nbuf, STATFIXLEN);
41         if (nbuf < STATFIXLEN)
42                 return 0;
43
44         p = buf;
45         ebuf = buf + nbuf;
46
47         p += BIT16SZ;   /* ignore size */
48         kd->d_type = GBIT16(p);
49         p += BIT16SZ;
50         junk = GBIT32(p);
51         p += BIT32SZ;
52         junk = GBIT8(p);
53         p += BIT8SZ;
54         junk = GBIT32(p);
55         p += BIT32SZ;
56         kd->d_ino = GBIT64(p);
57         p += BIT64SZ;
58         junk /* mode */  = GBIT32(p);
59         p += BIT32SZ;
60         junk /*d->atime */  = GBIT32(p);
61         p += BIT32SZ;
62         junk /*d->mtime */  = GBIT32(p);
63         p += BIT32SZ;
64         junk /*d->length */  = GBIT64(p);
65         p += BIT64SZ;
66
67         /* for now, uids in akaros are ints. Does not
68          * matter; kdirents are limited in what they tell you.
69          * get the name, ignore the rest. Maybe we can
70          * fix this later. 
71          */
72         for (i = 0; i < 4; i++) {
73                 if (p + BIT16SZ > ebuf)
74                         return 0;
75                 ns = GBIT16(p);
76                 p += BIT16SZ;
77                 if (p + ns > ebuf)
78                         return 0;
79                 if (i == 0) {
80                         kd->d_reclen = ns;
81                         printd("memmove %p %p %d\n", kd->d_name, p, ns);
82                         memmove(kd->d_name, p, ns);
83                         kd->d_name[ns] = 0;
84                 }
85                 p += ns;
86         }
87
88         printd("%s returns %d %s\n", __func__, p - buf, kd->d_name);
89         return p - buf;
90 }
91
92 unsigned int convM2kstat(uint8_t * buf, unsigned int nbuf, struct kstat *ks)
93 {
94         uint8_t *p, *ebuf;
95         char *sv[4];
96         int i, ns;
97         uint32_t junk;
98
99         if (nbuf < STATFIXLEN)
100                 return 0;
101
102         p = buf;
103         ebuf = buf + nbuf;
104
105         p += BIT16SZ;   /* ignore size */
106         junk /*kd->d_type */  = GBIT16(p);
107         p += BIT16SZ;
108         ks->st_rdev = ks->st_dev = GBIT32(p);
109         p += BIT32SZ;
110         junk /*qid.type */  = GBIT8(p);
111         p += BIT8SZ;
112         junk /*qid.vers */  = GBIT32(p);
113         p += BIT32SZ;
114         ks->st_ino = GBIT64(p);
115         p += BIT64SZ;
116         ks->st_mode = GBIT32(p);
117         if (ks->st_mode & DMDIR) {
118                 ks->st_mode &= ~DMDIR;
119                 ks->st_mode |= __S_IFDIR;
120         } else {
121                 ks->st_mode |= __S_IFREG;
122         }
123         p += BIT32SZ;
124         ks->st_atime.tv_sec = GBIT32(p);
125         p += BIT32SZ;
126         ks->st_mtime.tv_sec = GBIT32(p);
127         p += BIT32SZ;
128         ks->st_size = GBIT64(p);
129         p += BIT64SZ;
130         ks->st_blksize = 512;
131         ks->st_blocks = ROUNDUP(ks->st_size, ks->st_blksize) / ks->st_blksize;
132
133         ks->st_nlink = 2;       // links make no sense any more. 
134         ks->st_uid = ks->st_gid = 0;
135
136         return p - buf;
137  }