* Copyright 1999-2001, Be Incorporated. All Rights Reserved.
* Copyright 2024, Haiku, Inc. All rights reserved.
* This file may be used under the terms of the Be Sample Code License.
*/
#include "debug.h"
#ifndef FS_SHELL
#include <stdlib.h>
#endif
#define _KERNEL
extern "C" {
#include "sys/param.h"
#include "sys/buf.h"
#include "sys/conf.h"
#include "sys/iconv.h"
#include "sys/mount.h"
#include "sys/mutex.h"
#include "sys/namei.h"
#include "sys/vnode.h"
#include "fs/msdosfs/bootsect.h"
#include "fs/msdosfs/bpb.h"
#include "fs/msdosfs/denode.h"
#include "fs/msdosfs/direntry.h"
#include "fs/msdosfs/fat.h"
#include "fs/msdosfs/msdosfsmount.h"
}
#include "vcache.h"
static status_t
_dump_volume(const mount* bsdVolume, void (*printFunc)(const char*, ...))
{
#ifdef _KERNEL_MODE
if (bsdVolume == NULL)
return B_BAD_VALUE;
msdosfsmount* fatVolume = reinterpret_cast<msdosfsmount*>(bsdVolume->mnt_data);
cdev* dev = fatVolume->pm_dev;
if (FAT12(fatVolume) == true)
printFunc("FAT12 volume ");
else if (FAT16(fatVolume))
printFunc("FAT16 volume ");
else if (FAT32(fatVolume))
printFunc("FAT32 volume ");
printFunc("@ %p\n", bsdVolume);
printFunc("volume label [%s], file %s, device %" B_PRIdDEV ", fd %u,\n", dev->si_name,
dev->si_device, dev->si_id, dev->si_fd);
printFunc("mounted at %s\n", bsdVolume->mnt_stat.f_mntonname);
printFunc("msdosfsmount flags 0x%" B_PRIx64 ", media descriptor 0x%" B_PRIx8 "\n",
fatVolume->pm_flags, fatVolume->pm_Media);
printFunc("%" B_PRIu32 " bytes/sector, %lu sectors/cluster\n", fatVolume->pm_BytesPerSec,
SECTORS_PER_CLUSTER(fatVolume));
printFunc("%" B_PRIu16 " reserved sectors, %" B_PRIu16 " FATs, %lu blocks per FAT\n",
fatVolume->pm_ResSectors, fatVolume->pm_FATs, fatVolume->pm_FATsecs);
if (FAT32(fatVolume) == true) {
printFunc("fat mirroring is %s, fs info sector at block %lu, data start block %lu\n",
fatVolume->pm_curfat == 0 ? "on" : "off", fatVolume->pm_fsinfo,
fatVolume->pm_firstcluster);
} else {
printFunc("root start block %lu, %lu root blocks, data start block %lu\n",
fatVolume->pm_rootdirblk, fatVolume->pm_rootdirsize, fatVolume->pm_firstcluster);
}
printFunc("%" B_PRIu32 " total blocks, %lu max cluster number, %lu free clusters\n",
fatVolume->pm_HugeSectors, fatVolume->pm_maxcluster, fatVolume->pm_freeclustercount);
printFunc("last fake vnid %" B_PRIdINO ", vnid cache @ (%p %p)\n", bsdVolume->vcache.cur_vnid,
bsdVolume->vcache.by_vnid, bsdVolume->vcache.by_loc);
dump_vcache(bsdVolume);
#endif
return B_OK;
}
int
kprintf_volume(int argc, char** argv)
{
if ((argc == 1) || strcmp(argv[1], "--help") == 0) {
kprintf("usage: fat <address>\n"
" address: address of a FAT private volume (struct mount)\n"
" Use 'mounts' to list mounted volume ids, and 'mount <id>' to display a private "
"volume address.\n");
return 0;
}
mount* bsdVolume = reinterpret_cast<mount*>(strtoul(argv[1], NULL, 0));
return _dump_volume(bsdVolume, kprintf);
}
status_t
dprintf_volume(mount* bsdVolume)
{
#ifdef _KERNEL_MODE
return _dump_volume(bsdVolume, dprintf);
#else
return B_OK;
#endif
}
static status_t
_dump_node(const vnode* bsdNode, void (*printFunc)(const char*, ...))
{
#ifdef _KERNEL_MODE
if (bsdNode == NULL)
return B_BAD_VALUE;
denode* fatNode = reinterpret_cast<denode*>(bsdNode->v_data);
printFunc("private node @ %p\n", bsdNode);
printFunc("inode # %lu\n", fatNode->de_inode);
if (bsdNode->v_type == VNON)
printFunc("v_type VNON, ");
else if (bsdNode->v_type == VDIR)
printFunc("v_type VDIR, ");
else if (bsdNode->v_type == VREG)
printFunc("v_type VREG, ");
if (bsdNode->v_state == VSTATE_UNINITIALIZED)
printFunc("v_state VSTATE_UNINITIALIZED\n");
else if (bsdNode->v_state == VSTATE_CONSTRUCTED)
printFunc("v_state VSTATE_CONSTRUCTED\n");
printFunc("short name %s\n", fatNode->de_Name);
printFunc("entry cluster %lu\n", fatNode->de_dirclust);
printFunc("entry offset %lu\n", fatNode->de_diroffset);
printFunc("file start cluster %lu\n", fatNode->de_StartCluster);
printFunc("size %lu bytes\n", fatNode->de_FileSize);
printFunc("rw lock @ %p\n", &bsdNode->v_vnlock->haikuRW);
#endif
return B_OK;
}
int
kprintf_node(int argc, char** argv)
{
if ((argc == 1) || strcmp(argv[1], "--help") == 0) {
kprintf("usage: fat_node <address>\n"
" address: address of a FAT private node (BSD struct vnode)\n"
" Node addresses can be found with the 'vnodes' command.\n"
" If the driver was built with the DEBUG flag, the command 'fat' lists node"
"addresses\n");
return B_OK;
}
vnode* bsdNode = reinterpret_cast<vnode*>(strtoul(argv[1], NULL, 0));
return _dump_node(bsdNode, kprintf);
}
status_t
dprintf_node(vnode* bsdNode)
{
#ifdef _KERNEL_MODE
return _dump_node(bsdNode, dprintf);
#else
return B_OK;
#endif
}
status_t
dprintf_winentry(msdosfsmount* fatVolume, winentry* entry, const uint32* index)
{
#ifdef DEBUG
uint8 order = entry->weCnt & ~WIN_LAST;
mbnambuf namePart;
mbnambuf_init(&namePart);
win2unixfn(&namePart, entry, entry->weChksum, fatVolume);
namePart.nb_buf[(order - 1) * 14 + namePart.nb_len] = '\0';
char* namePtr = namePart.nb_buf + (order - 1) * 13;
const char* lastNote;
if ((entry->weCnt & WIN_LAST) != 0)
lastNote = " (last one)";
else
lastNote = "";
PRINT("index %" B_PRIu32 ": winentry %u%s, checksum %u, filename part %s\n", *index, order,
lastNote, entry->weChksum, namePtr);
#endif
return B_OK;
}
