Update kramfs to current coding conventions.

kernel/fs/kram.cpp

@@ -1,6 +1,6 @@
 /*******************************************************************************
 
-    Copyright(C) Jonas 'Sortie' Termansen 2012, 2013.
+    Copyright(C) Jonas 'Sortie' Termansen 2012, 2013, 2014.
 
     This file is part of Sortix.
 
@@ -113,17 +113,17 @@ Dir::Dir(dev_t dev, ino_t ino, uid_t owner, gid_t group, mode_t mode)
 		dev = (dev_t) this;
 	if ( !ino )
 		ino = (ino_t) this;
-	dirlock = KTHREAD_MUTEX_INITIALIZER;
+	dir_lock = KTHREAD_MUTEX_INITIALIZER;
 	this->stat_gid = owner;
 	this->stat_gid = group;
 	this->type = S_IFDIR;
 	this->stat_mode = (mode & S_SETABLE) | this->type;
 	this->dev = dev;
 	this->ino = ino;
-	numchildren = 0;
+	children_used = 0;
-	childrenlen = 0;
+	children_length = 0;
 	children = NULL;
-	shutdown = false;
+	shut_down = false;
 }
 
 Dir::~Dir()
@@ -131,15 +131,15 @@ Dir::~Dir()
 	// We must not be deleted or garbage collected if we are still used by
 	// someone. In that case the deleter should either delete our children or
 	// simply forget about us.
-	assert(!numchildren);
+	assert(!children_used);
 	delete[] children;
 }
 
 ssize_t Dir::readdirents(ioctx_t* ctx, struct kernel_dirent* dirent,
                          size_t size, off_t start, size_t /*maxcount*/)
 {
-	ScopedLock lock(&dirlock);
+	ScopedLock lock(&dir_lock);
-	if ( numchildren <= (uintmax_t) start )
+	if ( children_used <= (uintmax_t) start )
 		return 0;
 	struct kernel_dirent retdirent;
 	memset(&retdirent, 0, sizeof(retdirent));
@@ -172,7 +172,7 @@ ssize_t Dir::readdirents(ioctx_t* ctx, struct kernel_dirent* dirent,
 
 size_t Dir::FindChild(const char* filename)
 {
-	for ( size_t i = 0; i < numchildren; i++ )
+	for ( size_t i = 0; i < children_used; i++ )
 		if ( !strcmp(filename, children[i].name) )
 			return i;
 	return SIZE_MAX;
@@ -180,52 +180,57 @@ size_t Dir::FindChild(const char* filename)
 
 bool Dir::AddChild(const char* filename, Ref<Inode> inode)
 {
-	if ( numchildren == childrenlen )
+	if ( children_used == children_length )
 	{
-		size_t newchildrenlen = childrenlen ? 2 * childrenlen : 4;
+		size_t new_children_length = children_length ? 2 * children_length : 4;
-		DirEntry* newchildren = new DirEntry[newchildrenlen];
+		DirEntry* new_children = new DirEntry[new_children_length];
-		if ( !newchildren )
+		if ( !new_children )
 			return false;
-		for ( size_t i = 0; i < numchildren; i++ )
+		for ( size_t i = 0; i < children_used; i++ )
-			newchildren[i].inode = children[i].inode,
+		{
-			newchildren[i].name = children[i].name;
+			new_children[i].inode = children[i].inode;
-		delete[] children; children = newchildren;
+			new_children[i].name = children[i].name;
-		childrenlen = newchildrenlen;
+			children[i].inode.Reset();
+		}
+		delete[] children; children = new_children;
+		children_length = new_children_length;
 	}
-	char* filenamecopy = String::Clone(filename);
+	char* filename_copy = String::Clone(filename);
-	if ( !filenamecopy )
+	if ( !filename_copy )
 		return false;
 	inode->linked();
-	DirEntry* dirent = children + numchildren++;
+	DirEntry* dirent = &children[children_used++];
 	dirent->inode = inode;
-	dirent->name = filenamecopy;
+	dirent->name = filename_copy;
 	return true;
 }
 
 void Dir::RemoveChild(size_t index)
 {
-	assert(index < numchildren);
+	assert(index < children_used);
-	if ( index != numchildren-1 )
+	if ( index != children_used-1 )
 	{
 		DirEntry tmp = children[index];
-		children[index] = children[numchildren-1];
+		children[index] = children[children_used-1];
-		children[numchildren-1] = tmp;
+		children[children_used-1] = tmp;
-		index = numchildren-1;
+		index = children_used-1;
 	}
 	children[index].inode.Reset();
 	delete[] children[index].name;
-	numchildren--;
+	children_used--;
 }
 
 Ref<Inode> Dir::open(ioctx_t* ctx, const char* filename, int flags, mode_t mode)
 {
-	ScopedLock lock(&dirlock);
+	ScopedLock lock(&dir_lock);
-	if ( shutdown ) { errno = ENOENT; return Ref<Inode>(NULL); }
+	if ( shut_down )
-	size_t childindex = FindChild(filename);
+		return errno = ENOENT, Ref<Inode>(NULL);
-	if ( childindex != SIZE_MAX )
+	size_t child_index = FindChild(filename);
+	if ( child_index != SIZE_MAX )
 	{
-		if ( flags & O_EXCL ) { errno = EEXIST; return Ref<Inode>(NULL); }
+		if ( flags & O_EXCL )
-		return children[childindex].inode;
+			return errno = EEXIST, Ref<Inode>(NULL);
+		return children[child_index].inode;
 	}
 	if ( !(flags & O_CREATE) )
 		return errno = ENOENT, Ref<Inode>(NULL);
@@ -239,10 +244,12 @@ Ref<Inode> Dir::open(ioctx_t* ctx, const char* filename, int flags, mode_t mode)
 
 int Dir::mkdir(ioctx_t* ctx, const char* filename, mode_t mode)
 {
-	ScopedLock lock(&dirlock);
+	ScopedLock lock(&dir_lock);
-	if ( shutdown ) { errno = ENOENT; return -1; }
+	if ( shut_down )
-	size_t childindex = FindChild(filename);
+		return errno = ENOENT, -1;
-	if ( childindex != SIZE_MAX ) { errno = EEXIST; return -1; }
+	size_t child_index = FindChild(filename);
+	if ( child_index != SIZE_MAX )
+		return errno = EEXIST, -1;
 	Ref<Dir> dir(new Dir(dev, 0, ctx->uid, ctx->gid, mode));
 	if ( !dir )
 		goto cleanup_done;
@@ -263,100 +270,114 @@ cleanup_done:
 
 int Dir::rmdir(ioctx_t* ctx, const char* filename)
 {
-	if ( IsDotOrDotDot(filename) ) { errno = ENOTEMPTY; return -1; }
+	if ( IsDotOrDotDot(filename) )
-	ScopedLock lock(&dirlock);
+		return errno = ENOTEMPTY, -1;
-	if ( shutdown ) { errno = ENOENT; return -1; }
+	ScopedLock lock(&dir_lock);
-	size_t childindex = FindChild(filename);
+	if ( shut_down )
-	if ( childindex == SIZE_MAX ) { errno = ENOENT; return -1; }
+		return errno = ENOENT, -1;
-	Inode* child = children[childindex].inode.Get();
+	size_t child_index = FindChild(filename);
-	if ( !S_ISDIR(child->type) ) { errno = ENOTDIR; return -1; }
+	if ( child_index == SIZE_MAX )
-	if ( child->rmdir_me(ctx) < 0 ) { return -1; }
+		return errno = ENOENT, -1;
-	RemoveChild(childindex);
+	Inode* child = children[child_index].inode.Get();
+	if ( !S_ISDIR(child->type) )
+		return errno = ENOTDIR, -1;
+	if ( child->rmdir_me(ctx) < 0 )
+		return -1;
+	RemoveChild(child_index);
 	return 0;
 }
 
 int Dir::rmdir_me(ioctx_t* /*ctx*/)
 {
-	ScopedLock lock(&dirlock);
+	ScopedLock lock(&dir_lock);
-	if ( shutdown ) { errno = ENOENT; return -1; }
+	if ( shut_down )
-	for ( size_t i = 0; i < numchildren; i++ )
+		return errno = ENOENT, -1;
+	for ( size_t i = 0; i < children_used; i++ )
 		if ( !IsDotOrDotDot(children[i].name) )
 			return errno = ENOTEMPTY, -1;
-	shutdown = true;
+	shut_down = true;
-	for ( size_t i = 0; i < numchildren; i++ )
+	for ( size_t i = 0; i < children_used; i++ )
 	{
 		children[i].inode->unlinked();
 		children[i].inode.Reset();
 		delete[] children[i].name;
 	}
 	delete[] children; children = NULL;
-	numchildren = childrenlen = 0;
+	children_used = children_length = 0;
 	return 0;
 }
 
 int Dir::link(ioctx_t* /*ctx*/, const char* filename, Ref<Inode> node)
 {
-	if ( S_ISDIR(node->type) ) { errno = EPERM; return -1; }
+	if ( S_ISDIR(node->type) )
+		return errno = EPERM, -1;
 	// TODO: Is this needed? This may protect against file descriptors to
 	// deleted directories being used to corrupt kernel state, or something.
-	if ( IsDotOrDotDot(filename) ) { errno = EEXIST; return -1; }
+	if ( IsDotOrDotDot(filename) )
-	if ( node->dev != dev ) { errno = EXDEV; return -1; }
+		return errno = EEXIST, -1;
-	ScopedLock lock(&dirlock);
+	if ( node->dev != dev )
-	if ( shutdown ) { errno = ENOENT; return -1; }
+		return errno = EXDEV, -1;
-	size_t childindex = FindChild(filename);
+	ScopedLock lock(&dir_lock);
-	if ( childindex != SIZE_MAX )
+	if ( shut_down )
-	{
+		return errno = ENOENT, -1;
-		errno = EEXIST;
+	size_t child_index = FindChild(filename);
+	if ( child_index != SIZE_MAX )
+		return errno = EEXIST, -1;
+	if ( !AddChild(filename, node) )
 		return -1;
-	}
-	else
-		if ( !AddChild(filename, node) )
-			return -1;
 	return 0;
 }
 
 int Dir::link_raw(ioctx_t* /*ctx*/, const char* filename, Ref<Inode> node)
 {
-	if ( node->dev != dev ) { errno = EXDEV; return -1; }
+	if ( node->dev != dev )
-	ScopedLock lock(&dirlock);
+		return errno = EXDEV, -1;
-	size_t childindex = FindChild(filename);
+	ScopedLock lock(&dir_lock);
-	if ( childindex != SIZE_MAX )
+	size_t child_index = FindChild(filename);
+	if ( child_index != SIZE_MAX )
 	{
-		children[childindex].inode->unlinked();
+		children[child_index].inode->unlinked();
-		children[childindex].inode = node;
+		children[child_index].inode = node;
-		children[childindex].inode->linked();
+		children[child_index].inode->linked();
 	}
 	else
+	{
 		if ( !AddChild(filename, node) )
 			return -1;
+	}
 	return 0;
 }
 
 int Dir::unlink(ioctx_t* /*ctx*/, const char* filename)
 {
-	ScopedLock lock(&dirlock);
+	ScopedLock lock(&dir_lock);
-	if ( shutdown ) { errno = ENOENT; return -1; }
+	if ( shut_down )
-	size_t childindex = FindChild(filename);
+		return errno = ENOENT, -1;
-	if ( childindex == SIZE_MAX ) { errno = ENOENT; return -1; }
+	size_t child_index = FindChild(filename);
-	Inode* child = children[childindex].inode.Get();
+	if ( child_index == SIZE_MAX )
-	if ( S_ISDIR(child->type) ) { errno = EISDIR; return -1; }
+		return errno = ENOENT, -1;
-	RemoveChild(childindex);
+	Inode* child = children[child_index].inode.Get();
+	if ( S_ISDIR(child->type) )
+		return errno = EISDIR, -1;
+	RemoveChild(child_index);
 	return 0;
 }
 
 int Dir::unlink_raw(ioctx_t* /*ctx*/, const char* filename)
 {
-	ScopedLock lock(&dirlock);
+	ScopedLock lock(&dir_lock);
-	size_t childindex = FindChild(filename);
+	size_t child_index = FindChild(filename);
-	if ( childindex == SIZE_MAX ) { errno = ENOENT; return -1; }
+	if ( child_index == SIZE_MAX )
-	RemoveChild(childindex);
+		return errno = ENOENT, -1;
+	RemoveChild(child_index);
 	return 0;
 }
 
 int Dir::symlink(ioctx_t* /*ctx*/, const char* oldname, const char* filename)
 {
-	ScopedLock lock(&dirlock);
+	ScopedLock lock(&dir_lock);
-	if ( shutdown ) { errno = ENOENT; return -1; }
+	if ( shut_down )
+		return errno = ENOENT, -1;
 	(void) oldname;
 	(void) filename;
 	errno = ENOSYS;
@@ -376,18 +397,22 @@ int Dir::rename_here(ioctx_t* ctx, Ref<Inode> from, const char* oldname,
 	kthread_mutex_t* mutex_ptr1;
 	kthread_mutex_t* mutex_ptr2;
 	if ( from_dir->ino < this->ino )
-		mutex_ptr1 = &from_dir->dirlock,
+	{
-		mutex_ptr2 = &this->dirlock;
+		mutex_ptr1 = &from_dir->dir_lock;
+		mutex_ptr2 = &this->dir_lock;
+	}
 	else if ( from_dir->ino == this->ino )
 	{
-		mutex_ptr1 = &this->dirlock,
+		mutex_ptr1 = &this->dir_lock,
 		mutex_ptr2 = NULL;
 		if ( !strcmp(oldname, newname) )
 			return 0;
 	}
 	else
-		mutex_ptr1 = &this->dirlock,
+	{
-		mutex_ptr2 = &from_dir->dirlock;
+		mutex_ptr1 = &this->dir_lock;
+		mutex_ptr2 = &from_dir->dir_lock;
+	}
 	ScopedLock lock1(mutex_ptr1);
 	ScopedLock lock2(mutex_ptr2);
 
@@ -411,16 +436,18 @@ int Dir::rename_here(ioctx_t* ctx, Ref<Inode> from, const char* oldname,
 			Dir* existing_dir = (Dir*) existing.Get();
 			if ( !S_ISDIR(the_inode->type) )
 				return errno = EISDIR, -1;
-			assert(&existing_dir->dirlock != mutex_ptr1);
+			assert(&existing_dir->dir_lock != mutex_ptr1);
-			assert(&existing_dir->dirlock != mutex_ptr2);
+			assert(&existing_dir->dir_lock != mutex_ptr2);
 			if ( existing_dir->rmdir_me(ctx) != 0 )
 				return -1;
 		}
 		this->children[to_index].inode = the_inode;
 	}
 	else
+	{
 		if ( !this->AddChild(newname, the_inode) )
 			return -1;
+	}
 
 	from_dir->RemoveChild(from_index);
 

kernel/fs/kram.h

@@ -1,6 +1,6 @@
 /*******************************************************************************
 
-    Copyright(C) Jonas 'Sortie' Termansen 2012, 2013.
+    Copyright(C) Jonas 'Sortie' Termansen 2012, 2013, 2014.
 
     This file is part of Sortix.
 
@@ -82,11 +82,11 @@ private:
 	void RemoveChild(size_t index);
 
 private:
-	kthread_mutex_t dirlock;
+	kthread_mutex_t dir_lock;
-	size_t numchildren;
+	size_t children_used;
-	size_t childrenlen;
+	size_t children_length;
 	DirEntry* children;
-	bool shutdown;
+	bool shut_down;
 
 };