Network file systems are offered by Windows and (L)Unix. Is there one for IBM Mainframes? (Hard to believe not). Does it offer standard Unix-style access (binary? Ascii? EBCDIC?)
to mainframe data areas? How are datasets/partitioned data sets treated?
Who configures into Z/OS? How do I find out more about such network file systems for mainframes?
NFS is supported on System z.
So is SMB
Related
I am working on a raw/barebone embedded system, and I need to support some filesystem in it.
So I want to undestand the necessary interfaces between upper filesystem and lower block device.
Linux could be a reference, but its design is too complicated for an embedded system.
What I can think about is block_read() and block_write() interfaces which are called by filesystem to read/write data from/to block devices. Are they enough? And is there any other needed interface?
Thanks,
Most file systems targeted for embedded systems provide a porting interface that you need to change in-order to port the FS to your project.
The functions that you need to provide in the porting process are usually:
read from flash
write to flash
erase flash
lock flash
unlock flash
Once the porting is done the FS should be able to create and manipulate files.
Here are some open source file systems targeted for constrained systems:
FatFs
SPIFFS
littlefs
I have a smart card-like miniSD card (it's a javacard as far as I know) and I'm trying to write an emulator for it that runs on Windows and Linux. The emulator will be used in software integration tests. I want to test my client without using the actual hardware for several reasons. One reason is that the actual hardware will change its state irreversibly and doesn't allow a complete reset.
The device implements a mass storage with FAT32 file system. It contains a special device file that is being used for controlling the device via simple file write/read operations.
My goal is that the virtual (emulated) device appears with drive letter in Windows explorer as soon as the emulator is started, similar as if someone would actually plug a real device.
I wonder if there is any open software project that I can base my program on? The biggest challenges are obviously
Providing/developing a "virtual" (USB/SD) mass storage device
Intercepting file I/O operations on the special device file.
According to Wikipedia, device files are a common way to simplify driver development. So I wondered if there are existing emulation solutions for driver developers. At least I couldn't find any.
Simulating the device file itself would be an important first step. My first idea was to use a normal file and to communicate with the client by actually reading/writing to this file while observing it. I.e. clear the file as soon as the client wrote to it and write the response into it. I don't know if this could work at all. One problem is that the client doesn't open the file with shared mode, so my simulator cannot access it at the same time.
Then I found out that QEMU can emulate mass storage, however it seems that it only supports image files and that probably doesn't allow device file.
Microsoft has some documentation about how to write USB device emulators and drivers but it seems to be very complex and I wondered if there is an exisiting solution that could be extended:
Finally there is the USB/IP Project, but I don't know if it is helpful as I still need to develop a driver and then I'm back at the complex MS documentation above.
I am working on an upper volume filter driver using diskperf as base.
I am handling IRP_MJ_SHUTDOWN IRP, so while shutting down the system I want to save a buffer of size ranging from 30Mb to 500Mb.
So can I write this buffer to a file and when the system reboots again our driver should read the buffer from that file, so is this possible?
If yes, then can anyone guide me which functions to use for it?
Awaiting a positive response.
Thanks in advance.
The kernel provides a set of support routines to kernel-mode drivers, including ZwCreateFile (and various related functions) for working with files. So there is no need to attempt to construct requests to the file system drivers yourself.
I'm developping a "MP3 player"-like USB device. It is seen as a Mass Storage device by the USB host (Windows). I'd like to be able to keep the current song playing while the device is connected.
In an ideal world, the user should be able to delete every mp3 files using his file explorer but the one currently playing, which would be seen as "in use" by Windows.
The filesystem is FAT, I use FatFS for reading files on the device.
Does FAT allow such thing (mark a file as "in use") ? Any smarter idea ?
Like every filesystem that isn't specifically designed for this purpose, FAT isn't a cluster filesystem. As such, there are no provisions for mounting it from more than one host at a time. So it can't be mounted from the USB host's operating system and from the USB device's embedded operating system at the same time. The concept of a file being "in use" at the filesystem level is moot for a non-cluster filesystem.
For examples of cluster filesystems, look at OCFS2 or GFS2. But those require things like network lock managers and it is very unlikely that you can easily use them for an application like a USB device.
We've written a library that implements a filesystem-like API on top of a custom database system.
We'd like to be able to mount this filesystem as an ordinary filesytem from other machines across a network.
Are there any libraries, that can run in user space, that lets other machines on the network mount this and treat it like an ordinary file system? (Preferably in Python or C++)
One of the options is to use our Callback File System and expose the filesystem as a virtual disk, which can be shared using regular Windows sharing mechanisms. Callback File System includes a kernel-mode driver, needed to do the job, and offers user-mode C++ API which you use to expose your data as a filesystem.
Once there was .NET implementation of SMB server called WinFUSE, but it's long gone and almost no traces are left.
Update: On linux you can use FUSE to implement a filesystem and mount it, and then use some mechanisms (not necessarily a library) to expose the mounted filesystem as an SMB share.