vfs.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284
  1. /* Virtual filesystem: mount every device with a valid FAT filesystem under `/`. */
  2. #include "vfs.h"
  3. #include "fatdetect.h"
  4. #include "io.h"
  5. vfs_mount_t vfs_mounts[VFS_MAX_MOUNTS];
  6. unsigned int vfs_mount_count;
  7. static void put_dec(unsigned int n)
  8. {
  9. char buf[12];
  10. unsigned int i = sizeof(buf) - 1;
  11. buf[i] = '\0';
  12. if (n == 0) {
  13. io_putchar('0');
  14. return;
  15. }
  16. while (n && i > 0) {
  17. buf[--i] = (char)('0' + (n % 10));
  18. n /= 10;
  19. }
  20. io_putstr(buf + i);
  21. }
  22. static void put_size(unsigned int bytes)
  23. {
  24. if (bytes >= 1024u * 1024u * 1024u) {
  25. unsigned int gb = bytes / (1024u * 1024u * 1024u);
  26. unsigned int tenths = (bytes % (1024u * 1024u * 1024u)) * 10u / (1024u * 1024u * 1024u);
  27. put_dec(gb);
  28. if (tenths) {
  29. io_putchar('.');
  30. put_dec(tenths);
  31. }
  32. io_putstr(" GB");
  33. } else if (bytes >= 1024u * 1024u) {
  34. unsigned int mb = bytes / (1024u * 1024u);
  35. unsigned int tenths = (bytes % (1024u * 1024u)) * 10u / (1024u * 1024u);
  36. put_dec(mb);
  37. if (tenths) {
  38. io_putchar('.');
  39. put_dec(tenths);
  40. }
  41. io_putstr(" MB");
  42. } else {
  43. put_dec(bytes / 1024u);
  44. io_putstr(" KB");
  45. }
  46. }
  47. static const char *fat_name(fat_type_t t)
  48. {
  49. switch (t) {
  50. case FAT12: return "FAT12";
  51. case FAT16: return "FAT16";
  52. case FAT32: return "FAT32";
  53. default: return "FAT";
  54. }
  55. }
  56. static void mount_one(blk_dev_t *dev, unsigned int part_lba, const char *name)
  57. {
  58. fat_fs_t fs;
  59. unsigned int i;
  60. if (vfs_mount_count >= VFS_MAX_MOUNTS)
  61. return;
  62. if (fat_mount(dev, part_lba, &fs) != 0)
  63. return;
  64. for (i = 0; name[i] && i < sizeof(vfs_mounts[vfs_mount_count].name) - 1; i++)
  65. vfs_mounts[vfs_mount_count].name[i] = name[i];
  66. vfs_mounts[vfs_mount_count].name[i] = '\0';
  67. vfs_mounts[vfs_mount_count].fs = fs;
  68. vfs_mounts[vfs_mount_count].mounted = 1;
  69. vfs_mount_count++;
  70. }
  71. static void part_name(char *out, const char *base, unsigned int idx)
  72. {
  73. unsigned int i = 0;
  74. while (base[i] && i < 13) {
  75. out[i] = base[i];
  76. i++;
  77. }
  78. out[i++] = 'p';
  79. out[i++] = (char)('0' + idx + 1);
  80. out[i] = '\0';
  81. }
  82. void vfs_mount_all(void)
  83. {
  84. static unsigned char buf[512];
  85. unsigned int i;
  86. vfs_mount_count = 0;
  87. blk_scan();
  88. for (i = 0; i < blk_dev_count; i++) {
  89. blk_dev_t *d = &blk_devs[i];
  90. if (d->kind == BLK_IDE && !d->present)
  91. continue;
  92. if (d->kind == BLK_FLOPPY) {
  93. mount_one(d, 0, d->name);
  94. continue;
  95. }
  96. /* IDE: MBR -> FAT partitions, else superfloppy. */
  97. {
  98. mbr_part_t parts[4];
  99. int n, j;
  100. int any_fat = 0;
  101. if (blk_read(d, 0, buf, 1) != 0)
  102. continue;
  103. n = mbr_parse(buf, parts);
  104. for (j = 0; j < n; j++) {
  105. char pname[16];
  106. if (!parts[j].is_fat || parts[j].start_lba == 0 ||
  107. parts[j].sectors == 0)
  108. continue;
  109. any_fat = 1;
  110. part_name(pname, d->name, parts[j].index);
  111. mount_one(d, parts[j].start_lba, pname);
  112. }
  113. if (!any_fat)
  114. mount_one(d, 0, d->name);
  115. }
  116. }
  117. }
  118. vfs_mount_t *vfs_find(const char *name)
  119. {
  120. unsigned int i;
  121. for (i = 0; i < vfs_mount_count; i++) {
  122. unsigned int j = 0;
  123. while (vfs_mounts[i].name[j] && name[j] &&
  124. vfs_mounts[i].name[j] == name[j])
  125. j++;
  126. if (vfs_mounts[i].name[j] == '\0' && name[j] == '\0')
  127. return &vfs_mounts[i];
  128. }
  129. return 0;
  130. }
  131. void vfs_list_root(void)
  132. {
  133. unsigned int i;
  134. for (i = 0; i < vfs_mount_count; i++) {
  135. vfs_mount_t *m = &vfs_mounts[i];
  136. fat_fs_t *fs = &m->fs;
  137. io_putstr(m->name);
  138. io_putstr(" ");
  139. io_putstr(fat_name(fs->type));
  140. io_putchar(' ');
  141. put_size(fs->total_sectors * fs->bytes_per_sector);
  142. if (fs->label[0]) {
  143. io_putstr(" \"");
  144. io_putstr(fs->label);
  145. io_putchar('"');
  146. }
  147. io_putchar('\n');
  148. }
  149. }
  150. int vfs_resolve(const char *path, fat_fs_t **fs, const char **fs_path)
  151. {
  152. unsigned int i = 0, j;
  153. char name[16];
  154. vfs_mount_t *m;
  155. if (!path || path[0] != '/')
  156. return -1;
  157. i = 1;
  158. j = 0;
  159. while (path[i] && path[i] != '/' && j < sizeof(name) - 1)
  160. name[j++] = path[i++];
  161. name[j] = '\0';
  162. if (j == 0)
  163. return -1; /* path is just "/" */
  164. m = vfs_find(name);
  165. if (!m)
  166. return -1;
  167. *fs = &m->fs;
  168. *fs_path = path + i;
  169. return 0;
  170. }
  171. int vfs_join_path(const char *cwd, const char *arg, char *out, unsigned int out_size)
  172. {
  173. char buf[VFS_PATH_MAX * 2 + 2];
  174. unsigned int bi = 0;
  175. unsigned int len;
  176. const char *p;
  177. /* Build the combined (un-normalized) path. */
  178. if (arg[0] == '/') {
  179. p = arg;
  180. } else {
  181. p = cwd;
  182. while (*p && bi < sizeof(buf) - 1)
  183. buf[bi++] = *p++;
  184. if (bi > 0 && buf[bi - 1] != '/') {
  185. if (bi < sizeof(buf) - 1)
  186. buf[bi++] = '/';
  187. }
  188. p = arg;
  189. }
  190. while (*p && bi < sizeof(buf) - 1)
  191. buf[bi++] = *p++;
  192. buf[bi] = '\0';
  193. if (out_size < 2)
  194. return -1;
  195. /* Normalize into out (always begins with "/"). */
  196. out[0] = '/';
  197. out[1] = '\0';
  198. len = 1;
  199. p = buf;
  200. while (*p) {
  201. unsigned int clen = 0;
  202. const char *comp;
  203. while (*p == '/')
  204. p++;
  205. if (!*p)
  206. break;
  207. comp = p;
  208. while (*p && *p != '/') {
  209. p++;
  210. clen++;
  211. }
  212. if (clen == 1 && comp[0] == '.')
  213. continue;
  214. if (clen == 2 && comp[0] == '.' && comp[1] == '.') {
  215. /* Pop the previous component (may leave "/"). */
  216. while (len > 1 && out[len - 1] != '/')
  217. len--;
  218. if (len > 1)
  219. len--;
  220. out[len] = '\0';
  221. continue;
  222. }
  223. /* Append "/component". */
  224. if (len + 1 + clen + 1 > out_size)
  225. return -1;
  226. if (len > 1)
  227. out[len++] = '/';
  228. {
  229. unsigned int k;
  230. for (k = 0; k < clen; k++)
  231. out[len++] = comp[k];
  232. }
  233. out[len] = '\0';
  234. }
  235. return 0;
  236. }
  237. int vfs_device_known(const char *path)
  238. {
  239. unsigned int i = 0, j = 0;
  240. char name[16];
  241. if (!path || path[0] != '/')
  242. return 0;
  243. i = 1;
  244. while (path[i] && path[i] != '/' && j < sizeof(name) - 1)
  245. name[j++] = path[i++];
  246. name[j] = '\0';
  247. if (j == 0)
  248. return 0;
  249. return blk_find(name) != 0;
  250. }