int mkdir_chkpt_path(long app_id, unsigned int chkpt_sn)
{
char *buff;
char *dirname;
int r;
buff = kmalloc(PATH_MAX*sizeof(char), GFP_KERNEL);
if (!buff) {
r = -ENOMEM;
goto err_buff;
}
dirname = kmalloc(PATH_MAX*sizeof(char), GFP_KERNEL);
if (!dirname) {
r = -ENOMEM;
goto err_dirname;
}
snprintf(dirname, PATH_MAX, "%s", checkpointRoot);
if (app_id) {
snprintf(buff, PATH_MAX, "%ld/", app_id);
strncat(dirname, buff, PATH_MAX);
}
r = sys_mkdir(dirname, S_IRWXUGO|S_ISVTX);
if (r && r != -EEXIST)
goto err;
/* really force the mode without looking at umask */
r = sys_chmod(dirname, S_IRWXUGO|S_ISVTX);
if (r)
goto err;
if (chkpt_sn) {
snprintf(buff, PATH_MAX, "v%d/", chkpt_sn);
strncat(dirname, buff, PATH_MAX);
r = sys_mkdir(dirname, S_IRWXU);
if (r && r != -EEXIST)
goto err;
r = 0;
}
err:
kfree(dirname);
err_dirname:
kfree(buff);
err_buff:
return r;
}
static int create_dir(char *path)
{
int fd = -1;
BUG_ON(NULL == path);
fd = sys_access(path, 0);
if (fd) {
BB_PRINT_PN("need create dir %s\n", path);
fd = sys_mkdir(path, 0770);
if (fd < 0) {
BB_PRINT_ERR("create dir %s failed, fd:%d\n",
path, fd);
return -EBADF;
}
BB_PRINT_PN("create dir %s successed, fd: %d\n", path, fd);
}
/* change dir limit root-system */
if (bbox_chown((const char *)path, ROOT_UID, SYSTEM_GID, false)) {
BB_PRINT_ERR("[%s], chown %s dir failed\n", __func__, path);
}
return 0;
}
int main(int argc, char *argv[]){
int ret;
char *filename;
lcd_init();
lcd_setscrollmode(1);
if(argc != 2){
usage();
return 1;
}
filename = argv[1];
ret = sys_mkdir(filename, 0);
if(ret < 0){
switch(-ret){
case 3: // FAT_ERROR_INVALID_FILE_NAME
lcd_printf("invalid file name (%s)\n",filename);
break;
case 2: // FAT_ERROR_FILE_ALREADY_EXIST
lcd_printf("%s is already exist\n",filename);
break;
case 10: // FAT_ERROR_DISC_IS_FULL
lcd_printf("### ERROR ###\n");
lcd_printf("DISK IS FULL or SYSTEM ERROR\n");
break;
}
}else{
lcd_printf("create directory %s\n", argv[1]);
}
return 0;
}
static int __init mount_early_init( void )
{
int rt = 0, cnt = 0;
printk(KERN_ERR "start mount early partition\n");
rt = sys_mkdir("/dev/block",S_IRWXU|S_IRWXG|S_IRWXO);
if(rt < 0)
{
printk(KERN_ERR "sys_mkdir /dev/block fail\n");
return rt;
}
for(cnt = 0; cnt < sizeof(mount_list)/sizeof(mount_early); cnt++)
{
if(0 != (rt = mount_early_partition(&mount_list[cnt])))
{
printk(KERN_ERR "mount_early_partition failed!!! 0x%x\n", rt);
return rt;
}
}
#ifdef CONFIG_BALOMG_EARLY_FS_TEST
return mount_early_rw_test();
#endif
return 0;
}
/**
** sys_mkpath - ensure all directories in path exist
** Algorithm takes the pessimistic view and works top-down to ensure
** each directory in path exists, rather than optimistically creating
** the last element and working backwards.
*/
int sys_mkpath(const char *path, mode_t mode)
{
char *pp;
char *sp;
int status;
char *copypath = sys_malloc(strlen(path) + 1);
strcpy(copypath,path);
status = 0;
pp = copypath;
while (status == 0 && (sp = strchr(pp, '/')) != 0)
{
if (sp != pp)
{
/* Neither root nor double slash in path */
*sp = '\0';
status = sys_mkdir(copypath, mode);
*sp = '/';
}
pp = sp + 1;
}
sys_free((void**)©path);
assert(status == 0);
return status;
}
int rdr_open_dir(const char *dirname)
{
int fd;
struct kstat m_stat;
int error = vfs_stat("/data/lost+found", &m_stat);
if (error) {
DUMP_LOG(error);
return error;
}
rdr_create_dir(dirname);
fd = sys_open(dirname, O_DIRECTORY, 0);
if (fd < 0) { /* if dir is not exist,then create new dir */
DUMP_LOG(fd);
fd = sys_mkdir(dirname, 0774);
if (fd < 0) {
DUMP_LOG(fd);
return fd;
}
fd = sys_open(dirname, O_DIRECTORY, 0);
}
return fd;
}
static BOOL load_head( LOG_HEADER_T* head )
{
BOOL create = FALSE;
fs_handle_type file;
sys_mkdir(LOG_DIR, 0700);//make directory..
if((file = pantech_fopen( LOG_PATH, O_RDONLY, S_IRUSR | S_IWUSR)) != NULL) {
if( check_head_valid() == FALSE )
{
create = TRUE;
}
pantech_fclose(file);
} else {
create = TRUE;
}
if( create == TRUE )
{
if( create_log_file() == FALSE )
{
return FALSE;
}
}
file = open_log_file();
if( file == FS_NULL_HANDLE )
{
return FALSE;
}
head->first_log_pos_ = get_value( file, FIRST_LOG_POS, 6 ); // FIRST LOG
head->count_ = get_value( file, LOG_COUNT_POS, 4 ); // 로그수
head->head_ = get_value( file, HEAD_POS, 4 ); // head
head->tail_ = get_value( file, TAIL_POS, 4 ); // tail
head->free_head_ = get_value( file, FREE_HEAD_POS, 4 ); // free head
if( head->first_log_pos_ == (UINT32)-1 ||
head->count_ == (UINT32)-1 ||
head->head_ == (UINT32)-1 ||
head->tail_ == (UINT32)-1 ||
head->free_head_ == (UINT32)-1 )
{
goto _fail;
}
if( get_prev_next( file, head ) == FALSE )
{
goto _fail;
}
pantech_fclose( file );
return TRUE;
_fail:
pantech_fclose( file );
return FALSE;
}
/*
* create a directory with mode
*/
int mkdir(const char * path, u32_t mode)
{
char buf[MAX_PATH];
int err;
if((err = vfs_path_conv(path, buf)) !=0 )
return err;
return sys_mkdir(buf, mode);
}
asmlinkage long sys_csci3411_set_attr ( char *filename, char *attrname, char *attrvalue, int size )
{
struct stat sb ; /* necessary structure for using stat() */
char *fstring ; /* file/directory to give attribute to */
char *dstring ; /* temporary string for strstr() */
char buf[128] ; /* copy of the original filename */
char loc[128] ; /* full filepath for attr folder */
char cmd[128] ; /* command for system calls */
bool_t filetype ; /* is the tag for a file or dir? */
int fd ; /* file descriptor for attribute file */
mm_segment_t fs ; /* FS segment used to make sys calls */
fs = get_fs();
set_fs(get_ds());
/* check if filename is an existing file or directory */
if( sys_newstat(filename,&sb)==0 && S_ISREG(sb.st_mode) )
filetype = CSCI3411_FILE;
else if( sys_newstat(filename,&sb)==0 && S_ISDIR(sb.st_mode) )
filetype = CSCI3411_DIR;
else
return -1; /* file/directory does not exist */
/* split filename strings into containing folder and file */
fstring = strrchr(filename, '/');
fstring += sizeof(char);
copy_from_user( buf, filename, sizeof(buf)/sizeof(char));
dstring = strstr( buf, fstring );
strncpy( dstring,"\0",1);
sprintf(loc,"%s.%s_attr",buf,fstring);
/* check if attributes directory exists, mkdir if it doesn't */
if( sys_newstat(loc,&sb)==0 && S_ISDIR(sb.st_mode) );
else
sys_mkdir(loc,sb.st_mode);
/* create file in attribute directory
* in the event of a duplicate attribute file,
* overwrite with newer information */
sprintf(cmd,"%s/%s",loc,attrname);
sys_unlink(cmd); //remove file if it exists so we can make a new one
sys_mknod(cmd,sb.st_mode,0);
fd = sys_open(cmd,O_CREAT|O_WRONLY,0);
if(fd<0)
printk("file creation failed\n");
else
sys_write(fd,attrvalue,size);
set_fs(fs);
return 0;
}
static int parasite_get_proc_fd()
{
int ret, fd = -1;
char buf[2];
ret = sys_readlink("/proc/self", buf, sizeof(buf));
if (ret < 0 && ret != -ENOENT) {
sys_write_msg("Can't readlink /proc/self\n");
return ret;
}
/* Fast path -- if /proc belongs to this pidns */
if (ret == 1 && buf[0] == '1') {
fd = sys_open("/proc", O_RDONLY, 0);
goto out_send_fd;
}
if (sys_mkdir(proc_mountpoint, 0700)) {
sys_write_msg("Can't create a directory ");
sys_write_msg(proc_mountpoint);
sys_write_msg("\n");
return ret;
}
if (sys_mount("proc", proc_mountpoint, "proc", MS_MGC_VAL, NULL)) {
sys_write_msg("mount failed\n");
ret = -1;
goto out_rmdir;
}
fd = sys_open(proc_mountpoint, O_RDONLY, 0);
if (sys_umount2(proc_mountpoint, MNT_DETACH)) {
sys_write_msg("Can't umount procfs\n");
return -1;
}
out_rmdir:
if (sys_rmdir(proc_mountpoint)) {
sys_write_msg("Can't remove directory\n");
return -1;
}
out_send_fd:
if (fd < 0)
return fd;
ret = send_fd(tsock, NULL, 0, fd);
sys_close(fd);
return ret;
}
/*
* Create a simple rootfs that is similar to the default initramfs
*/
static int __init default_rootfs(void)
{
int err;
err = sys_mkdir("/dev", 0755);
if (err < 0)
goto out;
/* err = sys_mknod((const char __user *) "/dev/console",
S_IFCHR | S_IRUSR | S_IWUSR,
new_encode_dev(MKDEV(5, 1)));
if (err < 0)
goto out; */
err = sys_mkdir("/root", 0700);
if (err < 0)
goto out;
return 0;
out:
printk(KERN_WARNING "Failed to create a rootfs\n");
return err;
}
/*
* process MKDIR command
*/
static void rfs_mkdir(struct aipc_rfs_msg *msg)
{
struct aipc_rfs_open *param = (struct aipc_rfs_open*)msg->parameter;
int ret;
mm_segment_t oldfs = get_fs();
set_fs(KERNEL_DS);
ret = sys_mkdir(param->name, 0644);
set_fs(oldfs);
if(ret < 0) {
DMSG("rfs_mkdir error: %d\n", ret);
}
msg->msg_len = sizeof(struct aipc_rfs_msg) + sizeof(int);
msg->parameter[0] = ret;
}
static int hifi_create_dir(char *path)
{
int fd = -1;
fd = sys_access(path, 0);
if (0 != fd) {
logi("need create dir %s.\n", path);
fd = sys_mkdir(path, 0755);
if (fd < 0) {
loge("create dir %s fail, ret: %d.\n", path, fd);
return fd;
}
logi("create dir %s successed, fd: %d.\n", path, fd);
}
return 0;
}
/*****************************************************************************
函 数 名 : mount_early_partition
功能描述 : 挂载列表中的分区
输入参数 : mount_item:挂载列表
输出参数 :
返 回 值 : 成功/失败
调用函数 :
被调函数 :
*****************************************************************************/
static int mount_early_partition(mount_early *mount_item)
{
struct mtd_info *mtd;
int rt = 0;
char mount_name[32] ={0};
struct ST_PART_TBL *part = NULL;
part = find_early_partition(mount_item->img_type);
if(part != NULL){
mtd = get_mtd_device_nm(part->name);
if (IS_ERR(mtd)) {
printk("get_mtd_device_nm error.\n");
return PTR_ERR(mtd);
}
snprintf(mount_name, sizeof(mount_name) - 1, "/dev/block/mtdblock%d", mtd->index);
printk(KERN_DEBUG "going to mount %s mount point %s\n", mount_name, mount_item->mount_point);
if((rt = sys_mkdir(mount_item->mount_point, S_IRUSR | S_IRGRP)) < 0)
{
printk(KERN_ERR "create dir failed %s ret 0x%x\n", mount_item->mount_point, rt);
return rt ;
}
rt = sys_mknod(mount_name, S_IFBLK|S_IRWXU|S_IRWXG|S_IRWXO, MDEV_FS(31, mtd->index));
if(rt < 0)
{
printk(KERN_ERR "mknod failed %s ret 0x%x\n", mount_name, rt);
return rt ;
}
rt = sys_mount(mount_name, mount_item->mount_point, "yaffs2", 0, NULL);
if(rt < 0)
{
printk(KERN_ERR "mount failed %s %s ret 0x%x 0x%x\n", mount_name, \
mount_item->mount_point, rt, MKDEV(31,mtd->index));
return rt ;
}
return 0;
}else{
printk(KERN_ERR "no find nv dload partition!!!\n");
return 1 ;
}
}
int om_create_dir(char *path)
{
int fd;
/* 如果文件夹不存在，创建新文件夹*/
fd = sys_access(path, 0); //F_OK, 检查文件是否存在
if(0 != fd)
{
fd = sys_mkdir(path, 0660);
if(fd < 0)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_OM, "create om dir failed! ret = %d\n", fd);
return fd;
}
}
return BSP_OK;
}
static int ramdump_log_filename(void){
struct file *fp;
int err;
mm_segment_t old_fs;
fp = filp_open(DATA_LOGS , O_RDONLY, S_IRWXU|S_IRWXG|S_IRWXO);
if (PTR_ERR(fp) == -ENOENT) {
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_mkdir(DATA_LOGS,0777);
if (err < 0) {
set_fs(old_fs);
return -ENOENT;
}
set_fs(old_fs);
strcpy(rd_log_file, DATA_LOGS_RAMDUMP);
} else {
filp_close(fp,NULL);
strcpy(rd_log_file, DATA_LOGS_RAMDUMP);
}
return 0;
}
/* mkdir system call hook. */
static int
mkdir_hook(struct thread *td, void *syscall_args)
{
struct mkdir_args /* {
char *path;
int mode;
} */ *uap;
uap = (struct mkdir_args *)syscall_args;
char path[255];
size_t done;
int error;
error = copyinstr(uap->path, path, 255, &done);
if (error != 0)
return(error);
/* Print a debug message. */
uprintf("The directory \"%s\" will be created with the following"
" permissions: %o\n", path, uap->mode);
/* refer to sys_mkdir() at kern/vfs_syscalls.c */
return(sys_mkdir(td, syscall_args));
}
static int __rdr_create_dir(char *path)
{
int fd;
mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
fd = sys_access(path, 0);
if (0 != fd) {
pr_info("rdr: need create dir %s !\n", path);
fd = sys_mkdir(path, 0755);
if (fd < 0) {
pr_err("rdr: create dir %s failed! ret = %d\n",
path, fd);
set_fs(old_fs);
return fd;
}
pr_info("rdr: create dir %s successed [%d]!!!\n", path, fd);
}
set_fs(old_fs);
return 0;
}
dev_t name_to_dev_t(char *name)
{
char s[32];
char *p;
dev_t res = 0;
int part;
#ifdef CONFIG_SYSFS
int mkdir_err = sys_mkdir("/sys", 0700);
if (sys_mount("sysfs", "/sys", "sysfs", 0, NULL) < 0)
goto out;
#endif
if (strncmp(name, "/dev/", 5) != 0) {
unsigned maj, min;
if (sscanf(name, "%u:%u", &maj, &min) == 2) {
res = MKDEV(maj, min);
if (maj != MAJOR(res) || min != MINOR(res))
goto fail;
} else {
res = new_decode_dev(simple_strtoul(name, &p, 16));
if (*p)
goto fail;
}
goto done;
}
name += 5;
res = Root_NFS;
if (strcmp(name, "nfs") == 0)
goto done;
res = Root_RAM0;
if (strcmp(name, "ram") == 0)
goto done;
#if defined(CONFIG_MTD_BLOCK) || defined(CONFIG_MTD_BLOCK_RO)
/* Allow specification of MTD device by name, e.g.
* root=/dev/mtdblock:foo
* Similar to JFFS2-specific hack in prepare_namespace(),
* but more generic.
*/
if (strncmp(name, "mtdblock:", sizeof("mtdblock:") - 1) == 0) {
struct mtd_info *mtd =
get_mtd_device_nm(name + sizeof("mtdblock:") - 1);
if (unlikely(!mtd))
goto fail;
sprintf(name, "mtdblock%d", mtd->index);
put_mtd_device(mtd);
}
#endif
if (strlen(name) > 31)
goto fail;
strcpy(s, name);
for (p = s; *p; p++)
if (*p == '/')
*p = '!';
res = try_name(s, 0);
if (res)
goto done;
while (p > s && isdigit(p[-1]))
p--;
if (p == s || !*p || *p == '0')
goto fail;
part = simple_strtoul(p, NULL, 10);
*p = '\0';
res = try_name(s, part);
if (res)
goto done;
if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
goto fail;
p[-1] = '\0';
res = try_name(s, part);
done:
#ifdef CONFIG_SYSFS
sys_umount("/sys", 0);
out:
if (!mkdir_err)
sys_rmdir("/sys");
#endif
return res;
fail:
res = 0;
goto done;
}
/* Note: it is necessary to treat mode as an unsigned int,
* with the corresponding cast to a signed int to insure that the
* proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
* and the register representation of a signed int (msr in 64-bit mode) is performed.
*/
asmlinkage long compat_sys_mkdir(const char __user * pathname, u32 mode)
{
return sys_mkdir(pathname, (int)mode);
}
static void __init handle_initrd(void)
{
int error;
int pid;
real_root_dev = new_encode_dev(ROOT_DEV);
create_dev("/dev/root.old", Root_RAM0);
/* mount initrd on rootfs' /root */
mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);
sys_mkdir("/old", 0700);
root_fd = sys_open("/", 0, 0);
old_fd = sys_open("/old", 0, 0);
/* move initrd over / and chdir/chroot in initrd root */
sys_chdir("/root");
sys_mount(".", "/", NULL, MS_MOVE, NULL);
sys_chroot(".");
pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);
if (pid > 0) {
while (pid != sys_wait4(-1, NULL, 0, NULL)) {
try_to_freeze();
yield();
}
}
/* move initrd to rootfs' /old */
sys_fchdir(old_fd);
sys_mount("/", ".", NULL, MS_MOVE, NULL);
/* switch root and cwd back to / of rootfs */
sys_fchdir(root_fd);
sys_chroot(".");
sys_close(old_fd);
sys_close(root_fd);
if (new_decode_dev(real_root_dev) == Root_RAM0) {
sys_chdir("/old");
return;
}
ROOT_DEV = new_decode_dev(real_root_dev);
mount_root();
printk(KERN_NOTICE "Trying to move old root to /initrd ... ");
error = sys_mount("/old", "/root/initrd", NULL, MS_MOVE, NULL);
if (!error)
printk("okay\n");
else {
int fd = sys_open("/dev/root.old", O_RDWR, 0);
if (error == -ENOENT)
printk("/initrd does not exist. Ignored.\n");
else
printk("failed\n");
printk(KERN_NOTICE "Unmounting old root\n");
sys_umount("/old", MNT_DETACH);
printk(KERN_NOTICE "Trying to free ramdisk memory ... ");
if (fd < 0) {
error = fd;
} else {
error = sys_ioctl(fd, BLKFLSBUF, 0);
sys_close(fd);
}
printk(!error ? "okay\n" : "failed\n");
}
}
int GAPI mkdir(const char *name, unsigned int /*fixme*/ mode)
{
return sys_mkdir(name, mode);
}
static void
syscall_handler (struct intr_frame *f)
{
int syscall_number;
ASSERT( sizeof(syscall_number) == 4 ); // assuming x86
// The system call number is in the 32-bit word at the caller's stack pointer.
memread_user(f->esp, &syscall_number, sizeof(syscall_number));
_DEBUG_PRINTF ("[DEBUG] system call, number = %d!\n", syscall_number);
// Store the esp, which is needed in the page fault handler.
// refer to exception.c:page_fault() (see manual 4.3.3)
thread_current()->current_esp = f->esp;
// Dispatch w.r.t system call number
// SYS_*** constants are defined in syscall-nr.h
switch (syscall_number) {
case SYS_HALT: // 0
{
sys_halt();
NOT_REACHED();
break;
}
case SYS_EXIT: // 1
{
int exitcode;
memread_user(f->esp + 4, &exitcode, sizeof(exitcode));
sys_exit(exitcode);
NOT_REACHED();
break;
}
case SYS_EXEC: // 2
{
void* cmdline;
memread_user(f->esp + 4, &cmdline, sizeof(cmdline));
int return_code = sys_exec((const char*) cmdline);
f->eax = (uint32_t) return_code;
break;
}
case SYS_WAIT: // 3
{
pid_t pid;
memread_user(f->esp + 4, &pid, sizeof(pid_t));
int ret = sys_wait(pid);
f->eax = (uint32_t) ret;
break;
}
case SYS_CREATE: // 4
{
const char* filename;
unsigned initial_size;
bool return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
memread_user(f->esp + 8, &initial_size, sizeof(initial_size));
return_code = sys_create(filename, initial_size);
f->eax = return_code;
break;
}
case SYS_REMOVE: // 5
{
const char* filename;
bool return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_remove(filename);
f->eax = return_code;
break;
}
case SYS_OPEN: // 6
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_open(filename);
f->eax = return_code;
break;
}
case SYS_FILESIZE: // 7
{
int fd, return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_filesize(fd);
f->eax = return_code;
break;
}
case SYS_READ: // 8
{
int fd, return_code;
void *buffer;
unsigned size;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &buffer, sizeof(buffer));
memread_user(f->esp + 12, &size, sizeof(size));
return_code = sys_read(fd, buffer, size);
f->eax = (uint32_t) return_code;
break;
}
case SYS_WRITE: // 9
{
int fd, return_code;
const void *buffer;
unsigned size;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &buffer, sizeof(buffer));
memread_user(f->esp + 12, &size, sizeof(size));
return_code = sys_write(fd, buffer, size);
f->eax = (uint32_t) return_code;
break;
}
case SYS_SEEK: // 10
{
int fd;
unsigned position;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &position, sizeof(position));
sys_seek(fd, position);
break;
}
case SYS_TELL: // 11
{
int fd;
unsigned return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_tell(fd);
f->eax = (uint32_t) return_code;
break;
}
case SYS_CLOSE: // 12
{
int fd;
memread_user(f->esp + 4, &fd, sizeof(fd));
sys_close(fd);
break;
}
#ifdef VM
case SYS_MMAP: // 13
{
int fd;
void *addr;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &addr, sizeof(addr));
mmapid_t ret = sys_mmap (fd, addr);
f->eax = ret;
break;
}
case SYS_MUNMAP: // 14
{
mmapid_t mid;
memread_user(f->esp + 4, &mid, sizeof(mid));
sys_munmap(mid);
break;
}
#endif
#ifdef FILESYS
case SYS_CHDIR: // 15
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_chdir(filename);
f->eax = return_code;
break;
}
case SYS_MKDIR: // 16
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_mkdir(filename);
f->eax = return_code;
break;
}
case SYS_READDIR: // 17
{
int fd;
char *name;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &name, sizeof(name));
return_code = sys_readdir(fd, name);
f->eax = return_code;
break;
}
case SYS_ISDIR: // 18
{
int fd;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_isdir(fd);
f->eax = return_code;
break;
}
case SYS_INUMBER: // 19
{
int fd;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_inumber(fd);
f->eax = return_code;
break;
}
#endif
/* unhandled case */
default:
printf("[ERROR] system call %d is unimplemented!\n", syscall_number);
// ensure that waiting (parent) process should wake up and terminate.
sys_exit(-1);
break;
}
}
int panicable_mkdir( struct thread *thread,
struct mkdir_args *uap
)
{
/* a flag to indicate if should generate a panic or not */
int shouldPanic = 0;
#ifdef _LOCAL_PATH_
char localPath[ 255 ];
char *localPathPointer;
/* zero fill the memory */
memset( localPath, 0, 255 );
/* copy the mkdir path to a local variable, so it will be available
when using the debugger */
strcpy( localPath, uap->path );
/* copy also the pointer, to see the difference in the debugger */
localPathPointer = uap->path;
#endif /* _LOCAL_PATH */
#ifdef _MALLOC_ARGS_
char *kPath = malloc( strlen( uap->path ) + 1 , M_PANIC_MEMORY, M_NOWAIT | M_ZERO );
// copy the uap into the kernel version
copyinstr( uap->path, kPath, strlen( uap->path ), NULL );
#endif //_MALLOC_ARGS_
/* check if the path for the mkdir call
is contained into one of the panic paths defined
at the time of module load */
for( int i = 0;
moduleInitializationData != NULL && i < moduleInitializationData->count;
i++ ) {
if( strstr( uap->path, moduleInitializationData->names[ i ] ) != NULL ) {
/* the path contains a panicying word! */
shouldPanic = 1;
uprintf( "\nThe path [%s] will generate a panic, it contains panic word {%s (index %d)}\n",
uap->path,
moduleInitializationData->names[ i ],
i );
break;
}
}
#ifdef _MALLOC_ARGS_
/* since the free does not zeroes the memory, do it manually
to protect sensible data */
memset( localPathPointer, 0, strlen( uap->path ) + 1 );
free( localPathPointer, M_PANIC_MEMORY );
#endif //_MALLOC_ARGS_
/* should we call the standard mkdir or panic? */
if( ! shouldPanic ) {
/* ok, do a regular call */
return sys_mkdir( thread, uap );
}
else {
/* be polite, and sync dirty buffers */
sys_sync( thread, NULL );
panic( "Generating a panic from mkdir system call!" );
return shouldPanic; /* should never get here, just to keep quite the compiler */
}
}
dev_t name_to_dev_t(char *name)
{
char s[32];
char *p;
dev_t res = 0;
int part;
#ifdef CONFIG_SYSFS
int mkdir_err = sys_mkdir("/sys", 0700);
if (sys_mount("sysfs", "/sys", "sysfs", 0, NULL) < 0)
goto out;
#endif
if (strncmp(name, "/dev/", 5) != 0) {
unsigned maj, min;
if (sscanf(name, "%u:%u", &maj, &min) == 2) {
res = MKDEV(maj, min);
if (maj != MAJOR(res) || min != MINOR(res))
goto fail;
} else {
res = new_decode_dev(simple_strtoul(name, &p, 16));
if (*p)
goto fail;
}
goto done;
}
name += 5;
res = Root_NFS;
if (strcmp(name, "nfs") == 0)
goto done;
res = Root_RAM0;
if (strcmp(name, "ram") == 0)
goto done;
if (strlen(name) > 31)
goto fail;
strcpy(s, name);
for (p = s; *p; p++)
if (*p == '/')
*p = '!';
res = try_name(s, 0);
if (res)
goto done;
while (p > s && isdigit(p[-1]))
p--;
if (p == s || !*p || *p == '0')
goto fail;
part = simple_strtoul(p, NULL, 10);
*p = '\0';
res = try_name(s, part);
if (res)
goto done;
if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
goto fail;
p[-1] = '\0';
res = try_name(s, part);
done:
#ifdef CONFIG_SYSFS
sys_umount("/sys", 0);
out:
if (!mkdir_err)
sys_rmdir("/sys");
#endif
return res;
fail:
res = 0;
goto done;
}
static void __init handle_initrd(void)
{
int error;
int pid;
real_root_dev = new_encode_dev(ROOT_DEV);
create_dev("/dev/root.old", Root_RAM0);
/* mount initrd on rootfs' /root */
mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);
sys_mkdir((const char __user *)"/old", 0700);
root_fd = sys_open((const char __user *)"/", 0, 0);
old_fd = sys_open((const char __user *)"/old", 0, 0);
/* move initrd over / and chdir/chroot in initrd root */
sys_chdir((const char __user *)"/root");
sys_mount((char __user *)".", (char __user *)"/", NULL, MS_MOVE, NULL);
sys_chroot((const char __user *)".");
/*
* In case that a resume from disk is carried out by linuxrc or one of
* its children, we need to tell the freezer not to wait for us.
*/
current->flags |= PF_FREEZER_SKIP;
pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);
if (pid > 0)
while (pid != sys_wait4(-1, NULL, 0, NULL))
yield();
current->flags &= ~PF_FREEZER_SKIP;
/* move initrd to rootfs' /old */
sys_fchdir(old_fd);
sys_mount((char __user *)"/", (char __user *)".", NULL, MS_MOVE, NULL);
/* switch root and cwd back to / of rootfs */
sys_fchdir(root_fd);
sys_chroot((const char __user *)".");
sys_close(old_fd);
sys_close(root_fd);
if (new_decode_dev(real_root_dev) == Root_RAM0) {
sys_chdir((const char __user *)"/old");
return;
}
ROOT_DEV = new_decode_dev(real_root_dev);
mount_root();
printk(KERN_NOTICE "Trying to move old root to /initrd ... ");
error = sys_mount((char __user *)"/old", (char __user *)"/root/initrd", NULL, MS_MOVE, NULL);
if (!error)
printk("okay\n");
else {
int fd = sys_open((const char __user *)"/dev/root.old", O_RDWR, 0);
if (error == -ENOENT)
printk("/initrd does not exist. Ignored.\n");
else
printk("failed\n");
printk(KERN_NOTICE "Unmounting old root\n");
sys_umount((char __user *)"/old", MNT_DETACH);
printk(KERN_NOTICE "Trying to free ramdisk memory ... ");
if (fd < 0) {
error = fd;
} else {
error = sys_ioctl(fd, BLKFLSBUF, 0);
sys_close(fd);
}
printk(!error ? "okay\n" : "failed\n");
}
}
static void
syscall_handler (struct intr_frame *f )
{
/* VALUE */
int syscall_num;
int arg[5];
void *esp = f->esp;
/* VALUE */
check_address(esp);
syscall_num = *(int *)esp;
switch(syscall_num)
{
case SYS_HALT:
halt();
break;
case SYS_EXIT:
get_argument(esp,arg,1);
exit(arg[0]);
break;
case SYS_EXEC:
get_argument(esp,arg,1);
check_address((void *)arg[0]);
f->eax = exec((const char *)arg[0]);
break;
case SYS_WAIT:
get_argument(esp,arg,1);
f->eax = wait(arg[0]);
break;
case SYS_CREATE:
get_argument(esp,arg,2);
check_address((void *)arg[0]);
f->eax = create((const char *)arg[0],(unsigned)arg[1]);
break;
case SYS_REMOVE:
get_argument(esp,arg,1);
check_address((void *)arg[0]);
f->eax=remove((const char *)arg[0]);
break;
case SYS_OPEN:
get_argument(esp,arg,1);
check_address((void *)arg[0]);
f->eax = open((const char *)arg[0]);
break;
case SYS_FILESIZE:
get_argument(esp,arg,1);
f->eax = filesize(arg[0]);
break;
case SYS_READ:
get_argument(esp,arg,3);
check_address((void *)arg[1]);
f->eax = read(arg[0],(void *)arg[1],(unsigned)arg[2]);
break;
case SYS_WRITE:
get_argument(esp,arg,3);
check_address((void *)arg[1]);
f->eax = write(arg[0],(void *)arg[1],(unsigned)arg[2]);
break;
case SYS_SEEK:
get_argument(esp,arg,2);
seek(arg[0],(unsigned)arg[1]);
break;
case SYS_TELL:
get_argument(esp,arg,1);
f->eax = tell(arg[0]);
break;
case SYS_CLOSE:
get_argument(esp,arg,1);
close(arg[0]);
break;
case SYS_ISDIR:
get_argument(esp,arg,1);
sys_isdir(arg[0]);
break;
case SYS_MKDIR:
get_argument(esp, arg, 1);
check_address((void *)arg[0]);
f->eax = sys_mkdir((const char *)arg[0]);
break;
case SYS_READDIR:
get_argument(esp, arg, 2);
check_address((char *)arg[1]);
f->eax = sys_readdir(arg[0], (char *)arg[1]);
break;
case SYS_CHDIR:
get_argument(esp, arg, 1);
check_address((void *)arg[0]);
f->eax = sys_chdir((const char *)arg[0]);
break;
}
}
static int syscall_dispatch(uint32_t sysnum, uint32_t args, regs_t *regs)
{
switch (sysnum) {
case SYS_waitpid:
return sys_waitpid((waitpid_args_t *)args);
case SYS_exit:
do_exit((int)args);
panic("exit failed!\n");
return 0;
case SYS_thr_exit:
kthread_exit((void *)args);
panic("thr_exit failed!\n");
return 0;
case SYS_thr_yield:
sched_make_runnable(curthr);
sched_switch();
return 0;
case SYS_fork:
return sys_fork(regs);
case SYS_getpid:
return curproc->p_pid;
case SYS_sync:
sys_sync();
return 0;
#ifdef __MOUNTING__
case SYS_mount:
return sys_mount((mount_args_t *) args);
case SYS_umount:
return sys_umount((argstr_t *) args);
#endif
case SYS_mmap:
return (int) sys_mmap((mmap_args_t *) args);
case SYS_munmap:
return sys_munmap((munmap_args_t *) args);
case SYS_open:
return sys_open((open_args_t *) args);
case SYS_close:
return sys_close((int)args);
case SYS_read:
return sys_read((read_args_t *)args);
case SYS_write:
return sys_write((write_args_t *)args);
case SYS_dup:
return sys_dup((int)args);
case SYS_dup2:
return sys_dup2((dup2_args_t *)args);
case SYS_mkdir:
return sys_mkdir((mkdir_args_t *)args);
case SYS_rmdir:
return sys_rmdir((argstr_t *)args);
case SYS_unlink:
return sys_unlink((argstr_t *)args);
case SYS_link:
return sys_link((link_args_t *)args);
case SYS_rename:
return sys_rename((rename_args_t *)args);
case SYS_chdir:
return sys_chdir((argstr_t *)args);
case SYS_getdents:
return sys_getdents((getdents_args_t *)args);
case SYS_brk:
return (int) sys_brk((void *)args);
case SYS_lseek:
return sys_lseek((lseek_args_t *)args);
case SYS_halt:
sys_halt();
return -1;
case SYS_set_errno:
curthr->kt_errno = (int)args;
return 0;
case SYS_errno:
return curthr->kt_errno;
case SYS_execve:
return sys_execve((execve_args_t *)args, regs);
case SYS_stat:
return sys_stat((stat_args_t *)args);
case SYS_uname:
return sys_uname((struct utsname *)args);
case SYS_debug:
return sys_debug((argstr_t *)args);
case SYS_kshell:
return sys_kshell((int)args);
default:
dbg(DBG_ERROR, "ERROR: unknown system call: %d (args: %#08x)\n", sysnum, args);
curthr->kt_errno = ENOSYS;
return -1;
}
}
void *
init_fs(char *disk_name)
{
int err;
void *data = NULL;
init_block_cache(1024, 0);
init_vnode_layer();
err = sys_mkdir(1, -1, "/myfs", 0);
if (install_file_system(&myfs_ops, "myfs", 1, -1) == NULL) {
printf("can't install my file system\n");
exit(0);
}
data = sys_mount(1, "myfs", -1, "/myfs", disk_name, 0, NULL, 0);
if (data == NULL) {
printf("could not mount %s on /myfs\n", disk_name);
exit(0);
}
return data;
}
void *
init_fs(char *disk_name)
{
int err;
void *data = NULL;
init_block_cache(16348, 0);
init_vnode_layer();
err = sys_mkdir(1, -1, "/myfs", 0);
if (install_file_system(&fs_entry, "myfs", 1, -1) == NULL) {
printf("can't install my file system\n");
exit(0);
}
data = sys_mount(1, "myfs", -1, "/myfs", disk_name, 0, NULL, 0);
if (data == NULL) {
printf("could not mount %s on /myfs\n", disk_name);
exit(0);
}
err = sys_chdir(1, -1, "/myfs");
if (err != 0) {
printf("Failed to cd into /myfs.");
sys_unmount(1, -1, "/myfs");
exit(0);
}
return data;
}
