C++ NOT_YET_IMPLEMENTED函数代码示例

/*
 * See the comment in vfs.h for what is expected of this function.
 *
 * When this function returns, the inode refcount should be decremented.
 *
 * You probably want to use s5_free_inode() if there are no more links to
 * the inode, and dont forget to unpin the page
 */
static void
s5fs_delete_vnode(vnode_t *vnode)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_delete_vnode");
}

/*
 * range_perm is essentially a version of addr_perm that checks an entire
 * range of addresses (from avaddr to avaddr+len).  Though you will
 * probably want to use your addr_perm() function in your implementation of
 * range_perm, you don't need to check every possible address.  Remember
 * that page protections have, as the name suggests, page granularity.
 * Like addr_perm, this function should return 1 if the range is valid for
 * the given permissions, and 0 otherwise.
 */
int range_perm(struct proc *p, const void *avaddr, size_t len, int perm) {
  NOT_YET_IMPLEMENTED("VM: ***none***");
  return 0;
}

/*
 * Implementing this function is not required and strongly discouraged unless
 * you are absolutely sure your Weenix is perfect.
 *
 * This is the syscall entry point into vfs for mounting. You will need to
 * create the fs_t struct and populate its fs_dev and fs_type fields before
 * calling vfs's mountfunc(). mountfunc() will use the fields you populated
 * in order to determine which underlying filesystem's mount function should
 * be run, then it will finish setting up the fs_t struct. At this point you
 * have a fully functioning file system, however it is not mounted on the
 * virtual file system, you will need to call vfs_mount to do this.
 *
 * There are lots of things which can go wrong here. Make sure you have good
 * error handling. Remember the fs_dev and fs_type buffers have limited size
 * so you should not write arbitrary length strings to them.
 */
int
do_mount(const char *source, const char *target, const char *type)
{
        NOT_YET_IMPLEMENTED("MOUNTING: do_mount");
        return -EINVAL;
}

/*
 * Create a new directory entry in directory 'parent' with the given name, which
 * refers to the same file as 'child'.
 *
 * When this function returns, the inode refcount on the file that was linked to
 * should be incremented.
 *
 * Remember to incrament the ref counts appropriately
 *
 * You probably want to use s5_find_dirent(), s5_write_file(), and s5_dirty_inode().
 */
int
s5_link(vnode_t *parent, vnode_t *child, const char *name, size_t namelen)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_link");
        return -1;
}

/*
 * Return the disk-block number for the given seek pointer (aka file
 * position).
 *
 * If the seek pointer refers to a sparse block, and alloc is false,
 * then return 0. If the seek pointer refers to a sparse block, and
 * alloc is true, then allocate a new disk block (and make the inode
 * point to it) and return it.
 *
 * Be sure to handle indirect blocks!
 *
 * If there is an error, return -errno.
 *
 * You probably want to use pframe_get, pframe_pin, pframe_unpin, pframe_dirty.
 */
int
s5_seek_to_block(vnode_t *vnode, off_t seekptr, int alloc)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_seek_to_block");
        return -1;
}

/*
 * Write len bytes to the given inode, starting at seek bytes from the
 * beginning of the inode. On success, return the number of bytes
 * actually written (which should be 'len', unless there's only enough
 * room for a partial write); on failure, return -errno.
 *
 * This function should allow writing to files or directories, treating
 * them identically.
 *
 * Writing to a sparse block of the file should cause that block to be
 * allocated.  Writing past the end of the file should increase the size
 * of the file. Blocks between the end and where you start writing will
 * be sparse.
 *
 * Do not call s5_seek_to_block() directly from this function.  You will
 * use the vnode's pframe functions, which will eventually result in a
 * call to s5_seek_to_block().
 *
 * You will need pframe_dirty(), pframe_get(), memcpy().
 */
int
s5_write_file(vnode_t *vnode, off_t seek, const char *bytes, size_t len)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_write_file");
        return -1;
}

/*
 * Allocate a new disk-block off the block free list and return it. If
 * there are no free blocks, return -ENOSPC.
 *
 * This will not initialize the contents of an allocated block; these
 * contents are undefined.
 *
 * If the super block's s5s_nfree is 0, you need to refill 
 * s5s_free_blocks and reset s5s_nfree.  You need to read the contents 
 * of this page using the pframe system in order to obtain the next set of
 * free block numbers.
 *
 * Don't forget to dirty the appropriate blocks!
 *
 * You'll probably want to use lock_s5(), unlock_s5(), pframe_get(),
 * and s5_dirty_super()
 */
static int
s5_alloc_block(s5fs_t *fs)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_alloc_block");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * You probably want to use s5_find_dirent() and vget().
 */
int
s5fs_lookup(vnode_t *base, const char *name, size_t namelen, vnode_t **result)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_lookup");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * When this function returns, the inode refcount of the unlinked file
 * should be decremented.
 *
 * You probably want to use s5_remove_dirent().
 */
static int
s5fs_unlink(vnode_t *dir, const char *name, size_t namelen)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_unlink");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * When this function returns, the inode refcount of the file should be 2
 * and the vnode refcount should be 1.
 *
 * You probably want to use s5_alloc_inode(), s5_link(), and vget().
 */
static int
s5fs_create(vnode_t *dir, const char *name, size_t namelen, vnode_t **result)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_create");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * This function is similar to s5fs_create, but it creates a special
 * file specified by 'devid'.
 *
 * You probably want to use s5_alloc_inode, s5_link(), vget(), and vput().
 */
static int
s5fs_mknod(vnode_t *dir, const char *name, size_t namelen, int mode, devid_t devid)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_mknod");
        return -1;
}

/* Simply call s5_write_file. */
static int
s5fs_write(vnode_t *vnode, off_t offset, const void *buf, size_t len)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_write");
        return -1;
}

/* Simply call s5_read_file. */
static int
s5fs_read(vnode_t *vnode, off_t offset, void *buf, size_t len)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_read");
        return -1;
}

/*
 * See the comment in vfs.h for what is expected of this function.
 *
 * The vnode still exists on disk if it has a linkcount greater than 1.
 * (Remember, VFS takes a reference on the inode as long as it uses it.)
 *
 */
static int
s5fs_query_vnode(vnode_t *vnode)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_query_vnode");
        return 0;
}

/* To link:
 *      o open_namev(from)
 *      o dir_namev(to)
 *      o call the destination dir's (to) link vn_ops.
 *      o return the result of link, or an error
 *
 * Remember to vput the vnodes returned from open_namev and dir_namev.
 *
 * Error cases you must handle for this function at the VFS level:
 *      o EEXIST
 *        to already exists.
 *      o ENOENT
 *        A directory component in from or to does not exist.
 *      o ENOTDIR
 *        A component used as a directory in from or to is not, in fact, a
 *        directory.
 *      o ENAMETOOLONG
 *        A component of from or to was too long.
 *      o EISDIR
 *        from is a directory.
 */
int
do_link(const char *from, const char *to)
{
	NOT_YET_IMPLEMENTED("Link ");
	return -1;
	/*size_t namelen=0;
	const char *name=NULL;
	vnode_t *base = NULL;
	vnode_t *res_vnode_to=NULL;
	vnode_t *res_vnode_from=NULL;
	vnode_t *temp_vnode=NULL;

	KASSERT(from);
	KASSERT(to);

	int from_namev_ret=open_namev(from,NULL,&res_vnode_from,NULL);
	if(from_namev_ret<0)
	{
		KASSERT(from_namev_ret<0);
		dbg(DBG_PRINT,"(GRADING2D 3.g): From component has failed.\n");
		return from_namev_ret;
	}
	KASSERT(res_vnode_from);
	if(S_ISDIR(res_vnode_from->vn_mode))
	{
		KASSERT(S_ISDIR(res_vnode_from->vn_mode));
		dbg(DBG_PRINT, "(GRADING2D 3.g): From is a directory.\n");
		vput(res_vnode_from);
		return -EISDIR;
	}

	int to_namev_ret=dir_namev(to, &namelen,&name,NULL,&res_vnode_to);
	if(to_namev_ret<0)
	{*/
	/* Here we have to check if the vnode from has occurred successfully.
	  * If yes then simply vput the from */
	/*	KASSERT(to_namev_ret<0);
		dbg(DBG_PRINT,"(GRADING2D 3.g): To component has failed.\n");

		vput(res_vnode_from);
		return to_namev_ret;
	}
	KASSERT(res_vnode_to);

	if(!S_ISDIR(res_vnode_to->vn_mode))
	{
		KASSERT(!S_ISDIR(res_vnode_to->vn_mode));
		dbg(DBG_PRINT, "(GRADING2D 3.g): Some directory component is not a directory\n");
		vput(res_vnode_to);
		vput(res_vnode_from);
		return -ENOTDIR;
	}*/

	/* Need to check res_vnode before we call this to avoid conflict */
	/* To check if the path exists */
	/*KASSERT(name!=NULL);
	dbg(DBG_PRINT, "(GRADING2D 3.g): The name component is present\n");

	int loookup_ret=lookup(res_vnode_to,name,namelen,&temp_vnode);
	if(0==loookup_ret)
	{
		KASSERT(0==loookup_ret);
		dbg(DBG_PRINT, "(GRADING2D 3.g): The path exists. Would not be able to create the directory.\n");
		vput(res_vnode_to);
		vput(res_vnode_from);
		vput(temp_vnode);
		return -EEXIST;
	}

	KASSERT(res_vnode_to->vn_ops->link);
	int link_ret=(res_vnode_to->vn_ops->link)(res_vnode_from,res_vnode_to,name,namelen);
	vput(res_vnode_to);
	vput(res_vnode_from);

	if(link_ret<0){
		dbg(DBG_PRINT, "(GRADING2D 3.g): There is a problem in linking.\n");
		return link_ret;
	}

//.........这里部分代码省略.........