status_t
vfs_bootstrap_file_systems(void)
{
status_t status;
// bootstrap the root filesystem
status = _kern_mount("/", NULL, "rootfs", 0, NULL, 0);
if (status < B_OK)
panic("error mounting rootfs!\n");
_kern_setcwd(-1, "/");
// bootstrap the devfs
_kern_create_dir(-1, "/dev", 0755);
status = _kern_mount("/dev", NULL, "devfs", 0, NULL, 0);
if (status < B_OK)
panic("error mounting devfs\n");
// create directory for the boot volume
_kern_create_dir(-1, "/boot", 0755);
// create some standard links on the rootfs
for (int32 i = 0; sPredefinedLinks[i].path != NULL; i++) {
_kern_create_symlink(-1, sPredefinedLinks[i].path,
sPredefinedLinks[i].target, 0);
// we don't care if it will succeed or not
}
return B_OK;
}
/*! \brief Creates all missing directories along a given path.
\param path the directory path name.
\param mode a permission specification, which shall be used for the
newly created directories.
\return
- \c B_OK: Everything went fine.
- \c B_BAD_VALUE: \c NULL \a path.
- \c B_ENTRY_NOT_FOUND: \a path does not refer to a possible entry.
- \c B_PERMISSION_DENIED: Directory permissions didn't allow operation.
- \c B_NO_MEMORY: Insufficient memory for operation.
- \c B_LINK_LIMIT: Indicates a cyclic loop within the file system.
- \c B_BUSY: A node was busy.
- \c B_FILE_ERROR: A general file error.
- \c B_NOT_A_DIRECTORY: An entry other than a directory with that name does
already exist.
- \c B_NO_MORE_FDS: The application has run out of file descriptors.
\todo Check for efficency.
*/
status_t
create_directory(const char* path, mode_t mode)
{
if (!path)
return B_BAD_VALUE;
// That's the strategy: We start with the first component of the supplied
// path, create a BPath object from it and successively add the following
// components. Each time we get a new path, we check, if the entry it
// refers to exists and is a directory. If it doesn't exist, we try
// to create it. This goes on, until we're done with the input path or
// an error occurs.
BPath dirPath;
char* component;
int32 nextComponent;
do {
// get the next path component
status_t error = BPrivate::Storage::parse_first_path_component(path,
component, nextComponent);
if (error != B_OK)
return error;
// append it to the BPath
if (dirPath.InitCheck() == B_NO_INIT) // first component
error = dirPath.SetTo(component);
else
error = dirPath.Append(component);
delete[] component;
if (error != B_OK)
return error;
path += nextComponent;
// create a BEntry from the BPath
BEntry entry;
error = entry.SetTo(dirPath.Path(), true);
if (error != B_OK)
return error;
// check, if it exists
if (entry.Exists()) {
// yep, it exists
if (!entry.IsDirectory()) // but is no directory
return B_NOT_A_DIRECTORY;
} else {
// it doesn't exist -- create it
error = _kern_create_dir(-1, dirPath.Path(), mode & ~__gUmask);
if (error != B_OK)
return error;
}
} while (nextComponent != 0);
return B_OK;
}
/*! \brief Creates a new directory.
If an entry with the supplied name does already exist, the method fails.
\param path the new directory's path name. May be relative to this
directory or absolute.
\param dir a pointer to a BDirectory to be initialized to the newly
created directory. May be \c NULL.
\return
- \c B_OK: Everything went fine.
- \c B_BAD_VALUE: \c NULL \a path.
- \c B_ENTRY_NOT_FOUND: \a path does not refer to a possible entry.
- \c B_PERMISSION_DENIED: Directory permissions didn't allow operation.
- \c B_NO_MEMORY: Insufficient memory for operation.
- \c B_LINK_LIMIT: Indicates a cyclic loop within the file system.
- \c B_BUSY: A node was busy.
- \c B_FILE_ERROR: A general file error.
- \c B_FILE_EXISTS: An entry with that name does already exist.
- \c B_NO_MORE_FDS: The application has run out of file descriptors.
*/
status_t
BDirectory::CreateDirectory(const char* path, BDirectory* dir)
{
if (!path)
return B_BAD_VALUE;
// create the dir
status_t error = _kern_create_dir(fDirFd, path,
(S_IRWXU | S_IRWXG | S_IRWXO) & ~__gUmask);
if (error != B_OK)
return error;
if (dir == NULL)
return B_OK;
// init the supplied BDirectory
if (InitCheck() != B_OK || BPrivate::Storage::is_absolute_path(path))
return dir->SetTo(path);
return dir->SetTo(this, path);
}
int
mkdirat(int fd, const char *path, mode_t mode)
{
RETURN_AND_SET_ERRNO(_kern_create_dir(fd, path, mode & ~__gUmask));
}
static int
fuse_mkdir(const char* path, mode_t mode)
{
PRINTD("##mkdir\n");
return _ERR(_kern_create_dir(-1, path, mode));
}
static fssh_status_t
create_dir(const char *path, bool createParents)
{
// stat the entry
struct fssh_stat st;
fssh_status_t error = _kern_read_stat(-1, path, false, &st, sizeof(st));
if (error == FSSH_B_OK) {
if (createParents && FSSH_S_ISDIR(st.fssh_st_mode))
return FSSH_B_OK;
fprintf(stderr, "Error: Cannot make dir, entry \"%s\" is in the way.\n",
path);
return FSSH_B_FILE_EXISTS;
}
// the dir doesn't exist yet
// if we shall create all parents, do that first
if (createParents) {
// create the parent dir path
// eat the trailing '/'s
int len = strlen(path);
while (len > 0 && path[len - 1] == '/')
len--;
// eat the last path component
while (len > 0 && path[len - 1] != '/')
len--;
// eat the trailing '/'s
while (len > 0 && path[len - 1] == '/')
len--;
// Now either nothing remains, which means we had a single component,
// a root subdir -- in those cases we can just fall through (we should
// actually never be here in case of the root dir, but anyway) -- or
// there is something left, which we can call a parent directory and
// try to create it.
if (len > 0) {
char *parentPath = (char*)malloc(len + 1);
if (!parentPath) {
fprintf(stderr, "Error: Failed to allocate memory for parent "
"path.\n");
return FSSH_B_NO_MEMORY;
}
memcpy(parentPath, path, len);
parentPath[len] = '\0';
error = create_dir(parentPath, createParents);
free(parentPath);
if (error != FSSH_B_OK)
return error;
}
}
// make the directory
error = _kern_create_dir(-1,
path, (FSSH_S_IRWXU | FSSH_S_IRWXG | FSSH_S_IRWXO) & ~sUmask);
if (error != FSSH_B_OK) {
fprintf(stderr, "Error: Failed to make directory \"%s\": %s\n", path,
fssh_strerror(error));
return error;
}
return FSSH_B_OK;
}
