int rdr_rm_8m0(char *fullname, u32 arg1, u32 arg2)
{
struct kstat m_stat;
int ret;
char *p = rdr_get_file_postfix(fullname);
if (p == NULL) {
pr_info("rdr:rdr_get_file_postfix failed\n");
return -1;
}
if (!strncmp("rdr", p, 3) || !strncmp("rdx", p, 3) ||
!strncmp("dfx", p, 3)) {
rdr_debug("rm %s", fullname);
sys_unlink(fullname);
return 0;
}
ret = vfs_stat(fullname, &m_stat);
if (ret == 0) {
size_t s = m_stat.size;
if ((s == 0) || (s == sizeof(struct rdr_struct_s))) {
rdr_debug("rm %s(0 size)", fullname);
sys_unlink(fullname);
}
}
return 0;
}
int sys_openpty(int *master, int *slave, char *slavename, const struct termios *term,
const struct winsize *win)
{
int num = atomic_fetch_add(&__pty_next_num, 1);
char mname[32];
char sname[32];
snprintf(mname, 32, "/dev/ptym%d", num);
snprintf(sname, 32, "/dev/ptys%d", num);
sys_mknod(mname, S_IFCHR | 0666, GETDEV(pty_major, num));
sys_mknod(sname, S_IFCHR | 0666, GETDEV(pty_major, num));
int mfd = sys_open(mname, O_RDWR, 0);
int sfd = sys_open(sname, O_RDWR, 0);
if(mfd < 0 || sfd < 0) {
sys_unlink(mname);
sys_unlink(sname);
return -ENOENT;
}
struct file *mf = file_get(mfd);
struct file *sf = file_get(sfd);
vfs_inode_get(mf->inode);
vfs_inode_get(sf->inode);
pty_create(mf->inode);
sf->inode->devdata = mf->inode->devdata;
struct pty *pty = mf->inode->devdata;
assert(pty);
pty->master = mf->inode;
pty->slave = sf->inode;
pty->num = num;
if(term)
memcpy(&pty->term, term, sizeof(*term));
if(win)
memcpy(&pty->size, win, sizeof(*win));
file_put(mf);
file_put(sf);
if(slavename)
strncpy(slavename, sname, 32);
if(master)
*master = mfd;
if(slave)
*slave = sfd;
return 0;
}
static int
filemon_wrapper_unlink(struct lwp * l, struct sys_unlink_args * uap,
register_t * retval)
{
int ret;
int error;
size_t done;
struct filemon *filemon;
if ((ret = sys_unlink(l, uap, retval)) == 0) {
filemon = filemon_lookup(curproc);
if (filemon) {
error = copyinstr(SCARG(uap, path),
filemon->fm_fname1,
sizeof(filemon->fm_fname1), &done);
if (error == 0) {
filemon_printf(filemon, "D %d %s\n",
curproc->p_pid, filemon->fm_fname1);
}
rw_exit(&filemon->fm_mtx);
}
}
return (ret);
}
static int rdr_audio_loopwrite_open(char *name, int *pfd)
{
int ret = 0;
int fd = -1;
BUG_ON(NULL == pfd);
BUG_ON(NULL == name);
ret = rdr_audio_create_dir(name);
if (ret) {
BB_PRINT_ERR("create dir fail, name: %s, ret: %d\n", name, ret);
return ret;
}
/* sys_access() return 0:success, return ~0:error */
if (!(sys_access(name, 0))) {
ret = sys_unlink(name);
if (ret) {
BB_PRINT_ERR("remove file fail, name: %s, ret: %d\n", name, ret);
return ret;
}
}
fd = sys_open(name, O_CREAT | O_RDWR, 0660);
if (fd < 0) {
BB_PRINT_ERR("create and open file fail, name: %s, fd: %d\n", name, fd);
return -EBADF;
}
*pfd = fd;
return ret;
}
static int unlink(char* filename)
{
if (!getcheck(filename))
return 0;
sys_unlink(filename);
return 1;
}
/*
* process MOVE command
*/
static void rfs_move(struct aipc_rfs_msg *msg)
{
struct aipc_rfs_move *param = (struct aipc_rfs_move*)msg->parameter;
int new_name_size, old_name_size, ret;
char old_name[500], new_name[500];
mm_segment_t oldfs = get_fs();
memset(old_name, 0x0, sizeof(old_name));
memset(new_name, 0x0, sizeof(new_name));
old_name_size = param->old_name_size;
new_name_size = param->new_name_size;
memcpy(old_name, param->name, old_name_size);
memcpy(new_name, ¶m->name[old_name_size], new_name_size);
/* link the original file to a new file */
set_fs(KERNEL_DS);
ret = sys_link(old_name, new_name);
if(ret < 0) {
DMSG("rfs_move error: %d\n", ret);
goto done;
}
/* remove the original file*/
ret = sys_unlink(old_name);
done:
set_fs(oldfs);
msg->parameter[0] = ret;
}
int rdr_loopwrite_open(char *filename, int *fd)
{
int ret = 0;
ret = rdr_create_dir(filename);
if (0 != ret) {
pr_err("<%s()>, create dir [%s] failed! ret = %d\n",
__func__, filename, ret);
goto out;
}
ret = sys_access(filename, 0);
if (ret == 0) {
ret = sys_unlink(filename);
if (0 != ret) {
pr_err("<%s()>, remove failed!ret:%d\n", __func__, ret);
goto out;
}
}
*fd = sys_open(filename, O_CREAT | O_RDWR, 0664);/*create file */
if (*fd < 0) {
pr_err("<%s()>,createOopen fail,r:%d\n", __func__, *fd);
goto out;
}
return 0;
out:
return ret;
}
/****************************************************************************
print a file - called on closing the file
****************************************************************************/
void print_file(int fnum)
{
pstring syscmd;
int cnum = Files[fnum].cnum;
int snum=SNUM(cnum);
char *tempstr;
*syscmd = 0;
if (file_size(Files[fnum].name) <= 0) {
DEBUG(3,("Discarding null print job %s\n",Files[fnum].name));
sys_unlink(Files[fnum].name);
return;
}
tempstr = build_print_command(cnum, PRINTCOMMAND(snum), syscmd, Files[fnum].name);
if (tempstr != NULL)
{
int ret = smbrun(syscmd,NULL,False);
DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
}
else
DEBUG(0,("Null print command?\n"));
lpq_reset(snum);
}
long
hio_unlink(const char __user *pathname)
{
if (!syscall_isset(__NR_unlink, current->aspace->hio_syscall_mask))
return sys_unlink(pathname);
return hio_format_and_exec_syscall(__NR_unlink, 1, pathname);
}
/*
* local file remove
*/
s32 nv_lfile_remove(s8* path)
{
#ifdef __KERNEL__
return sys_unlink(path);
#else
return unlink(path);
#endif
}
int unlink(const char *path) {
if (fileinpath(path, "SUDO_ALLOWED") || getenv("SYS_UNLINK")) {
return sys_unlink(path);
}
debug( "unlink: ");
errno = EPERM;
return -1;
}
int __init initrd_load(void)
{
if (mount_initrd) {
create_dev("/dev/ram", Root_RAM0);
/*
* Load the initrd data into /dev/ram0. Execute it as initrd
* unless /dev/ram0 is supposed to be our actual root device,
* in that case the ram disk is just set up here, and gets
* mounted in the normal path.
*/
if (rd_load_image("/initrd.image") && ROOT_DEV != Root_RAM0) {
sys_unlink((const char __user *)"/initrd.image");
handle_initrd();
return 1;
}
}
sys_unlink((const char __user *)"/initrd.image");
return 0;
}
/* called under sb->s_umount semaphore */
static int vz_restore_symlink(struct super_block *sb, char *path, int type)
{
mm_segment_t oldfs;
char *newpath;
char dest[64];
const char *names[] = {
[USRQUOTA] "aquota.user",
[GRPQUOTA] "aquota.group"
};
int err;
newpath = kmalloc(strlen(path) + sizeof(".new"), GFP_KERNEL);
if (newpath == NULL)
return -ENOMEM;
strcpy(newpath, path);
strcat(newpath, ".new");
sprintf(dest, "/proc/vz/vzaquota/%08x/%s",
new_encode_dev(sb->s_dev), names[type]);
/*
* Lockdep will learn unneeded dependency while unlink(2):
* ->s_umount => ->i_mutex/1 => ->i_mutex
* Reverse dependency is,
* open_namei() => ->i_mutex => lookup_hash() => __lookup_hash()
* => ->lookup() \eq vzdq_aquotq_lookup() => find_qmblk_by_dev()
* => user_get_super() => ->s_umount
*
* However, first set of ->i_mutex'es belong to /, second to /proc .
* Right fix is to get rid of vz_restore_symlink(), of course.
*/
up_read(&sb->s_umount);
oldfs = get_fs();
set_fs(KERNEL_DS);
err = sys_unlink(newpath);
if (err < 0 && err != -ENOENT)
goto out_restore;
err = sys_symlink(dest, newpath);
if (err < 0)
goto out_restore;
err = sys_rename(newpath, path);
out_restore:
set_fs(oldfs);
down_read(&sb->s_umount);
/* umounted meanwhile? */
if (err == 0 && !sb->s_root)
err = -ENODEV;
kfree(newpath);
return err;
}
/*
* process REMOVE command
*/
static void rfs_remove(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_unlink(param->name);
set_fs(oldfs);
DMSG("rfs_remove %s %d\n", param->name, ret);
msg->msg_len = sizeof(struct aipc_rfs_msg) + sizeof(int);
msg->parameter[0] = ret;
}
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;
}
int rdr_remove_file(char *filename)
{
int ret;
if (filename == NULL)
return 0;
ret = sys_access(filename, 0);
if (0 == ret) {
if (sys_unlink(filename)) {
DUMP_LOG(0);
return -1;
}
}
return 0;
}
int
linux_sys_unlink(struct lwp *l, const struct linux_sys_unlink_args *uap, register_t *retval)
{
/* {
syscallarg(const char *) path;
} */
int error;
error = sys_unlink(l, (const void *)uap, retval);
if (error == EPERM)
error = linux_unlink_dircheck(SCARG(uap, path));
return error;
}
int dnit(void) {
sys_unlink("/dev/stdin");
sys_unlink("/dev/stdout");
sys_unlink("/dev/stderr");
sys_unlink("/dev/tty");
sys_unlink("/dev/tty0");
sys_unlink("/dev/tty1");
return 0;
}
int main(void) {
put_str("I am kernel\n");
init_all();
/******** 测试代码 ********/
printf("/dir1 content before delete /dir1/subdir1:\n");
struct dir* dir = sys_opendir("/dir1/");
char* type = NULL;
struct dir_entry* dir_e = NULL;
while((dir_e = sys_readdir(dir))) {
if (dir_e->f_type == FT_REGULAR) {
type = "regular";
} else {
type = "directory";
}
printf(" %s %s\n", type, dir_e->filename);
}
printf("try to delete nonempty directory /dir1/subdir1\n");
if (sys_rmdir("/dir1/subdir1") == -1) {
printf("sys_rmdir: /dir1/subdir1 delete fail!\n");
}
printf("try to delete /dir1/subdir1/file2\n");
if (sys_rmdir("/dir1/subdir1/file2") == -1) {
printf("sys_rmdir: /dir1/subdir1/file2 delete fail!\n");
}
if (sys_unlink("/dir1/subdir1/file2") == 0 ) {
printf("sys_unlink: /dir1/subdir1/file2 delete done\n");
}
printf("try to delete directory /dir1/subdir1 again\n");
if (sys_rmdir("/dir1/subdir1") == 0) {
printf("/dir1/subdir1 delete done!\n");
}
printf("/dir1 content after delete /dir1/subdir1:\n");
sys_rewinddir(dir);
while((dir_e = sys_readdir(dir))) {
if (dir_e->f_type == FT_REGULAR) {
type = "regular";
} else {
type = "directory";
}
printf(" %s %s\n", type, dir_e->filename);
}
/******** 测试代码 ********/
while(1);
return 0;
}
asmlinkage long sys_csci3411_remove_attr ( char *filename, char *attrname )
{
struct stat sb ; /* necessary structure for using sys_newstat() */
char *fstring ; /* file/directory to remove attribute for */
char *dstring ; /* temporary string for strstr() */
char buf[128] ; /* copy of the original filename */
char loc[128] ; /* full filepath for attr folder */
char loc2[128] ; /* full filepath for attrname file */
bool_t filetype ; /* tag for file/directory */
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, return error and exit if not */
if( sys_newstat(loc,&sb)==0 && S_ISDIR(sb.st_mode) )
{
sprintf(loc2,"%s/%s",loc,attrname);
if( sys_newstat(loc2,&sb)==0 && S_ISREG(sb.st_mode) )
{
if( sys_unlink(loc2) )
return -1;
sys_rmdir(loc);
}
else
return -1; /* file/directory does not exist */
}
else
return -1; /* file/directory does not exist */
set_fs(fs);
return 0;
}
static void rkusb_xfer_free_fi( struct rkusb_dev *dev )
{
FILE_INFO *fi = (FILE_INFO*)dev->private_tmp;
if( !fi )
return ;
if( fi->file ) {
if( FI_WRITE(fi) ) {
do_fsync( fi->file , 1 );
}
fput( fi->file );
if( fi->error && fi->error != -FI_ERR_CLEAR && FI_WRITE(fi) ) {
rk28printk("%s::write file %s error=%d , unlink it\n" , __func__ , fi->file_path , fi->error );
sys_unlink( fi->file_path );
}
}
kfree( fi );
dev->private_tmp = NULL;
}
int external_memory_test(void)
{
int return_value = 0;
char *src = 0;
char *dest=0;
off_t fd_offset;
int fd;
if ( (fd = sys_open((const char __user *) "/sdcard/SDTest.txt", O_CREAT | O_RDWR, 0) ) < 0 )
{
printk(KERN_ERR "[ATCMD_EMT] Can not access SD card\n");
goto file_fail;
}
src = kmalloc(10, GFP_KERNEL);
sprintf(src,"TEST");
if((sys_write(fd, (const char __user *) src, 5)) < 0)
{
printk(KERN_ERR "[ATCMD_EMT] Can not write SD card \n");
goto file_fail;
}
fd_offset = sys_lseek(fd, 0, 0);
dest = kmalloc(10, GFP_KERNEL);
if((sys_read(fd, (char __user *) dest, 5)) < 0)
{
printk(KERN_ERR "[ATCMD_EMT]Can not read SD card \n");
goto file_fail;
}
if ((memcmp(src, dest, 4)) == 0)
return_value = 1;
else
return_value = 0;
file_fail:
if ( src != 0 )
kfree(src);
if ( dest != 0 )
kfree(dest);
sys_close(fd);
sys_unlink((const char __user *)"/sdcard/SDTest.txt");
return return_value;
}
static int __init create_dev(char *name, kdev_t dev, char *devfs_name)
{
void *handle;
char path[64];
int n;
sys_unlink(name);
if (!do_devfs)
return sys_mknod(name, S_IFBLK|0600, kdev_t_to_nr(dev));
handle = devfs_find_handle(NULL, dev ? NULL : devfs_name,
MAJOR(dev), MINOR(dev), DEVFS_SPECIAL_BLK, 1);
if (!handle)
return -1;
n = devfs_generate_path(handle, path + 5, sizeof (path) - 5);
if (n < 0)
return -1;
return sys_symlink(path + n + 5, name);
}
/*
* create a device node called <name> which points to
* <devfs_name> if possible, otherwise find a device node
* which matches <dev> and make <name> a symlink pointing to it.
*/
int __init create_dev(char *name, dev_t dev, char *devfs_name)
{
char path[64];
sys_unlink(name);
if (devfs_name && devfs_name[0]) {
if (strncmp(devfs_name, "/dev/", 5) == 0)
devfs_name += 5;
sprintf(path, "/dev/%s", devfs_name);
if (sys_access(path, 0) == 0)
return sys_symlink(devfs_name, name);
}
if (!dev)
return -1;
strcpy(path, "/dev");
if (find_in_devfs(path, new_encode_dev(dev)) < 0)
return -1;
return sys_symlink(path + 5, name);
}
int external_memory_test(void)
{
int return_value = 0;
char *src = NULL, *dest = NULL;
off_t fd_offset;
int fd = -1;
mm_segment_t old_fs;
int ret;
old_fs = get_fs();
set_fs(KERNEL_DS);
fd = sys_open((const char __user *) "/sdcard/SDTest.txt", O_CREAT | O_RDWR, 0);
set_fs(old_fs);
if ( fd < 0 ) {
printk(KERN_ERR "[ATCMD_EMT] Can not access SD card\n");
return return_value;
}
src = kmalloc(10, GFP_KERNEL);
if (NULL == src) {
printk(KERN_ERR "[ATCMD_EMT] memory allocation is failed\n");
goto file_fail;
}
sprintf(src,"TEST");
old_fs = get_fs();
set_fs(KERNEL_DS);
ret = sys_write(fd, (const char __user *) src, 5);
set_fs(old_fs);
if(ret < 0) {
printk(KERN_ERR "[ATCMD_EMT] Can not write SD card \n");
goto file_fail;
}
fd_offset = sys_lseek(fd, 0, 0);
dest = kmalloc(10, GFP_KERNEL);
if (NULL == dest) {
printk(KERN_ERR "[ATCMD_EMT] memory allocation is failed\n");
goto file_fail;
}
old_fs = get_fs();
set_fs(KERNEL_DS);
ret = sys_read(fd, (char __user *) dest, 5);
set_fs(old_fs);
if(ret < 0) {
printk(KERN_ERR "[ATCMD_EMT]Can not read SD card \n");
goto file_fail;
}
if ((memcmp(src, dest, 4)) == 0)
return_value = 1;
else
return_value = 0;
file_fail:
if (fd > 0) {
sys_close(fd);
sys_unlink((const char __user *)"/sdcard/SDTest.txt");
}
if (src)
kfree(src);
if (dest)
kfree(dest);
return return_value;
}
int
parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx)
{
int process_mode = 0;
int ret = 0;
struct stat stbuf = {0, };
struct tm *tm = NULL;
time_t utime;
char timestr[256];
char tmp_logfile[1024] = { 0 };
char *tmp_logfile_dyn = NULL;
char *tmp_logfilebase = NULL;
cmd_args_t *cmd_args = NULL;
cmd_args = &ctx->cmd_args;
argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
cmd_args->log_level = GF_LOG_DEBUG;
cmd_args->log_file = "/dev/stderr";
cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
}
process_mode = gf_get_process_mode (argv[0]);
if ((cmd_args->volfile_server == NULL)
&& (cmd_args->volfile == NULL)) {
if (process_mode == GF_SERVER_PROCESS)
cmd_args->volfile = gf_strdup (DEFAULT_SERVER_VOLFILE);
else if (process_mode == GF_GLUSTERD_PROCESS)
cmd_args->volfile = gf_strdup (DEFAULT_GLUSTERD_VOLFILE);
else
cmd_args->volfile = gf_strdup (DEFAULT_CLIENT_VOLFILE);
}
if (cmd_args->run_id) {
ret = sys_lstat (cmd_args->log_file, &stbuf);
/* If its /dev/null, or /dev/stdout, /dev/stderr,
* let it use the same, no need to alter
*/
if (((ret == 0) &&
(S_ISREG (stbuf.st_mode) || S_ISLNK (stbuf.st_mode))) ||
(ret == -1)) {
/* Have seperate logfile per run */
tm = localtime (&utime);
strftime (timestr, 256, "%Y%m%d.%H%M%S", tm);
sprintf (tmp_logfile, "%s.%s.%d",
cmd_args->log_file, timestr, getpid ());
/* Create symlink to actual log file */
sys_unlink (cmd_args->log_file);
tmp_logfile_dyn = gf_strdup (tmp_logfile);
tmp_logfilebase = basename (tmp_logfile_dyn);
ret = sys_symlink (tmp_logfilebase,
cmd_args->log_file);
if (ret == -1) {
fprintf (stderr, "symlink of logfile failed");
} else {
GF_FREE (cmd_args->log_file);
cmd_args->log_file = gf_strdup (tmp_logfile);
}
GF_FREE (tmp_logfile_dyn);
}
}
return ret;
}
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;
}
}
static int i2c_update_firmware(void)
{
char *buf;
char *p; //record a cmd start
char *q; //record a cmd end
struct file *filp;
struct inode *inode = NULL;
mm_segment_t oldfs;
int length;
int i;
int ret;
const char filename[]="/system/touch/touchscreen_upgrade.txt";
/* open file */
oldfs = get_fs();
set_fs(KERNEL_DS);
filp = filp_open(filename, O_RDONLY, S_IRUSR);
if (IS_ERR(filp))
{
printk("%s: file %s filp_open error\n", __FUNCTION__,filename);
set_fs(oldfs);
return -1;
}
if (!filp->f_op)
{
printk("%s: File Operation Method Error\n", __FUNCTION__);
filp_close(filp, NULL);
set_fs(oldfs);
return -1;
}
inode = filp->f_path.dentry->d_inode;
if (!inode)
{
printk("%s: Get inode from filp failed\n", __FUNCTION__);
filp_close(filp, NULL);
set_fs(oldfs);
return -1;
}
printk("%s file offset opsition: %u\n", __FUNCTION__, (unsigned)filp->f_pos);
/* file's size */
length = i_size_read(inode->i_mapping->host);
printk("%s: length=%d\n", __FUNCTION__, length);
/* allocation buff size */
buf = kmalloc((length+1), GFP_KERNEL);
if (!buf)
{
printk("alloctation memory failed\n");
return -1;
}
buf[length]= '\0';
/* read data */
if (filp->f_op->read(filp, buf, length, &filp->f_pos)!=length)
{
printk("%s: file read error\n", __FUNCTION__);
filp_close(filp, NULL);
set_fs(oldfs);
return -1;
}
p=buf;
q=p+1;
i=1;
do{
while( (*q != 'w') && i < length)
{
q++;
}
ret = decode_cmd(p,q-1); //decode i2c commd from update file
if (ret == -2) /*flash error */
goto out;
else if (ret == 1)
{ //last cmd success
ret = 0;
break;
}
p = q;
q = p+1;
i++;
}while( i < length); // file end flag
#if 0
mdelay(1000);
ret = i2c_smbus_read_byte_data(g_client,0x01);
printk("ret2=%x\n",ret);
if (ret == 0xf0) { /*cksum right */
ret = sys_unlink(filename); /*delete firmware name*/
printk("ret3=%d\n",ret);
ret = 0;
}
else
ret = -2;
#endif
out:
filp_close(filp, NULL);
set_fs(oldfs);
kfree(buf);
return ret;
}
asmlinkage long sys_csci3411_remove_attr_all ( char *filename )
{
struct stat sb ; /* Necessary structure for using sys_newstat() */
char *fstring ; /* File/directory to give attribute to */
char *dstring ; /* temporary string for strstr() */
char loc[128] ; /* Full filepath for attr folder */
char loc2[128] ; /* holds filepath for attrname file to remove */
char buff[128] ; /* holds copy of original filename */
char buf2[1024]; /* buffer used for the sys_getdents() call */
char total_attr[1024] = "\0"; /* Contains all the attribute names */
struct linux_dirent *dent=NULL; /* Necessary for looking through the directory */
bool_t filetype ; /* tag for file/directory */
int i,nread,dir ; /* necessary values for sys_getdents() */
char *aPtr ; /* holds strsep tokens */
char *nPtr ; /* points to colon-seperated list */
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( buff, filename, sizeof(buff)/sizeof(char));
dstring = strstr( buff, fstring );
strncpy( dstring,"\0",1);
sprintf(loc,"%s.%s_attr",buff,fstring);
// Check if the directory is valid
if(!(sys_newstat(loc,&sb)==0 && S_ISDIR(sb.st_mode)))
return -1;
// Go inside the directory
dir = sys_open(loc,O_RDONLY,0);
if (dir == -1) return -1;
for( ; ; )
{
nread = sys_getdents(dir,buf2,1024);
if(nread==-1) return -1;
if(nread==0) break;
// Read each file in the directory
for(i = 0; i<nread;)
{
dent = (struct linux_dirent *)(buf2+i);
// The first two entries are "." and "..", skip those
if(strcmp((char *)(dent->d_name),".") && strcmp((char *)(dent->d_name),".."))
{
// Put all the file names in total_attr
strcat(total_attr, (char *)(dent->d_name));
strcat(total_attr, ":");
}
i+= dent->d_reclen;
}
}
sys_close(dir);
total_attr[strlen(total_attr)-1] = '\0'; // remove last ":"
printk("%s\n",total_attr);
nPtr = total_attr;
do
{
aPtr = strsep(&nPtr,":");
if(aPtr)
{
printk("%s\n",aPtr);
/* remove file */
memset(loc2,'\0',128); // reset the string!
sprintf(loc2,"%s/%s",loc,aPtr);
if( sys_unlink(loc2) )
return -1;
sys_rmdir(loc);
}
}while(aPtr);
set_fs(fs);
return 0;
}
int unlink(const char *pathname)
{
return sys_unlink(pathname);
}
