int rdr_mov2up(char *fullname, char *dstfullname, u32 arg2)
{
/* whether the fullname is rdr/rdx/dfx file */
char *p = rdr_get_file_postfix(fullname);
char *name;
int shouldmov = 0;
struct kstat m_stat;
if (p == NULL)
return -1;
if (!strncmp("rdr", p, 3) || !strncmp("rdx", p, 3) ||
!strncmp("dfx", p, 3)) {
if (0 == vfs_stat(fullname, &m_stat)) {
if (m_stat.size == sizeof(struct rdr_struct_s))
shouldmov = 1;
}
}
if (shouldmov == 1) {
char xname[64];
name = rdr_get_file_name(fullname);
if (name == NULL)
return -1;
memset(xname, 0, sizeof(xname));
strncpy(xname, dstfullname, sizeof(xname) - 1);
strncat(xname, name, sizeof(xname) - strlen(dstfullname) - 1);
xname[sizeof(xname) - 1] = '\0';
rdr_debug("move %s to %s", fullname, xname);
if (0 != sys_rename(fullname, xname))
pr_err("rdr:mv from %s to %s fail\n", fullname, xname);
}
return 0;
}
static int
filemon_wrapper_rename(struct lwp * l, struct sys_rename_args * uap,
register_t * retval)
{
int ret;
int error;
size_t done;
struct filemon *filemon;
if ((ret = sys_rename(l, uap, retval)) == 0) {
filemon = filemon_lookup(curproc);
if (filemon) {
error = copyinstr(SCARG(uap, from), filemon->fm_fname1,
sizeof(filemon->fm_fname1), &done);
if (error == 0)
error = copyinstr(SCARG(uap, to),
filemon->fm_fname2,
sizeof(filemon->fm_fname2), &done);
if (error == 0) {
filemon_printf(filemon,
"M %d '%s' '%s'\n",
curproc->p_pid, filemon->fm_fname1,
filemon->fm_fname2);
}
rw_exit(&filemon->fm_mtx);
}
}
return (ret);
}
/* 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;
}
int
gf_changelog_done (char *file)
{
int ret = -1;
char *buffer = NULL;
xlator_t *this = NULL;
gf_changelog_journal_t *jnl = NULL;
char to_path[PATH_MAX] = {0,};
errno = EINVAL;
this = THIS;
if (!this)
goto out;
jnl = (gf_changelog_journal_t *) GF_CHANGELOG_GET_API_PTR (this);
if (!jnl)
goto out;
if (!file || !strlen (file))
goto out;
/* make sure 'file' is inside ->jnl_working_dir */
buffer = realpath (file, NULL);
if (!buffer)
goto out;
if (strncmp (jnl->jnl_working_dir,
buffer, strlen (jnl->jnl_working_dir)))
goto out;
(void) snprintf (to_path, PATH_MAX, "%s%s",
jnl->jnl_processed_dir, basename (buffer));
gf_msg_debug (this->name, 0,
"moving %s to processed directory", file);
ret = sys_rename (buffer, to_path);
if (ret) {
gf_smsg (this->name, GF_LOG_ERROR, errno,
CHANGELOG_LIB_MSG_RENAME_FAILED,
"cannot move changelog file",
"from=%s", file,
"to=%s", to_path,
NULL);
goto out;
}
ret = 0;
out:
if (buffer)
free (buffer); /* allocated by realpath() */
return ret;
}
int rename(const char *oldpath, const char *newpath) {
if (fileinpath(oldpath, "SUDO_ALLOWED") ||
fileinpath(newpath, "SUDO_ALLOWED") ||
getenv("SYS_RENAME")) {
return sys_rename(oldpath, newpath);
}
debug( "rename: ");
errno = EPERM;
return -1;
}
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;
}
}
int rename(const char *oldname, const char *newname)
{
return sys_rename(oldname, newname);
}
int om_clear_old_file(int fd, char * header)
{
int ret = BSP_OK;
int i;
int index;
int head_len;
int read_bytes;
char *buf = BSP_NULL;
struct linux_dirent *dir;
char filename[OM_DUMP_FILE_MAX_NUM][OM_DUMP_FILE_NAME_LENGTH] = {{0},{0}};
char temp[OM_DUMP_FILE_NAME_LENGTH];
buf = kmalloc(1024, GFP_KERNEL);
if(BSP_NULL == buf)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_OM, "om_clear_old_file: Alloc mem error!");
return BSP_ERROR;
}
read_bytes = sys_getdents(fd, (struct linux_dirent *)buf, 1024);
if(-1 == read_bytes)
{
/* 读取文件夹错误 */
om_error("<om_clear_old_file>, dents error!\n");
ret = BSP_ERROR;
goto out;
}
if(0 == read_bytes)
{
/* 文件夹是空的，直接返回OK */
ret = BSP_OK;
goto out;
}
/*轮询文件夹*/
head_len = strlen(header);
for(i=0; i<read_bytes; )
{
dir = (struct linux_dirent *)(buf + i);
i += (int)dir->d_reclen;
/* 删除旧的和错误的文件 */
if(0 == strncmp ((char *)dir->d_name, header, head_len))
{
strncpy(temp, OM_ROOT_PATH, OM_DUMP_FILE_NAME_LENGTH-1);
strncat(temp, dir->d_name, OM_DUMP_FILE_NAME_LENGTH-strlen(OM_ROOT_PATH)-1);
index = simple_strtol(dir->d_name + head_len, NULL, 0);
// 如果索引号超过最大值，或者有重复，直接删除文件
if((index >= OM_DUMP_FILE_MAX_NUM - 1) || (0 != filename[index][0]))
{
sys_unlink(temp);
}
else
{
strncpy(filename[index], temp, OM_DUMP_FILE_NAME_LENGTH -1);
}
}
}
/* 文件重命名 */
for(i=OM_DUMP_FILE_MAX_NUM-2; i>=0; i--)
{
if(filename[i][0])
{
snprintf(temp, sizeof(temp), "%s%s%02d.bin", OM_ROOT_PATH, OM_DUMP_HEAD, i+1);
/* coverity[check_return] */
(void)sys_rename(filename[i], temp);
}
}
out:
if(buf)
kfree(buf);
return ret;
}
int
rename(const char *old_path, const char *new_path) {
return sys_rename(old_path, new_path);
}
void log_file_size_check(char *filename)
{
struct file *file;
loff_t file_size = 0;
int i = 0;
char buf1[1024] = {0};
char buf2[1024] = {0};
mm_segment_t old_fs = get_fs();
int ret = 0;
set_fs(KERNEL_DS);
if (filename) {
file = filp_open(filename, O_RDONLY, 0666);
sys_chmod(filename, 0666);
} else {
TOUCH_E("%s : filename is NULL, can not open FILE\n",
__func__);
goto error;
}
if (IS_ERR(file)) {
TOUCH_I("%s : ERR(%ld) Open file error [%s]\n",
__func__, PTR_ERR(file), filename);
goto error;
}
file_size = vfs_llseek(file, 0, SEEK_END);
TOUCH_I("%s : [%s] file_size = %lld\n",
__func__, filename, file_size);
filp_close(file, 0);
if (file_size > MAX_LOG_FILE_SIZE) {
TOUCH_I("%s : [%s] file_size(%lld) > MAX_LOG_FILE_SIZE(%d)\n",
__func__, filename, file_size, MAX_LOG_FILE_SIZE);
for (i = MAX_LOG_FILE_COUNT - 1; i >= 0; i--) {
if (i == 0)
sprintf(buf1, "%s", filename);
else
sprintf(buf1, "%s.%d", filename, i);
ret = sys_access(buf1, 0);
if (ret == 0) {
TOUCH_I("%s : file [%s] exist\n", __func__, buf1);
if (i == (MAX_LOG_FILE_COUNT - 1)) {
if (sys_unlink(buf1) < 0) {
TOUCH_E(
"%s : failed to remove file [%s]\n",
__func__, buf1);
goto error;
}
TOUCH_I(
"%s : remove file [%s]\n",
__func__, buf1);
} else {
sprintf(buf2, "%s.%d", filename,
(i + 1));
if (sys_rename(buf1, buf2) < 0) {
TOUCH_E(
"%s : failed to rename file [%s] -> [%s]\n",
__func__, buf1, buf2);
goto error;
}
TOUCH_I(
"%s : rename file [%s] -> [%s]\n",
__func__, buf1, buf2);
}
} else {
TOUCH_I("%s : file [%s] does not exist (ret = %d)\n", __func__, buf1, ret);
}
}
}
error:
set_fs(old_fs);
return;
}
int del_old_file(const char *dirname, const char *file_header,
unsigned int fd, const char *header)
{
long read_bytes;
size_t head_len, j, min;
void *buf;
int index, i;
struct linux_dirent *dir;
char fname[RDR_FILE_MAX_CNT][RDR_FNAME_LEN+1] = { {0} };
char temp_fname[RDR_FNAME_LEN+1];
char str2int_buf[16];
char *p_dname;
buf = kmalloc(1024, GFP_KERNEL);
if (NULL == buf)
return -1;
read_bytes = sys_getdents(fd, (struct linux_dirent *)buf, 1024);
if ((read_bytes == 0) || (read_bytes < 0)) { /* -1 or 0 */
kfree(buf);
return (int)read_bytes;
}
head_len = strlen(header);
for (i = 0; i < read_bytes; ) { /*begin to poll dir : */
dir = (struct linux_dirent *)((char *)buf + i);
i += dir->d_reclen;
/* delete old and error file: */
if (0 == strncmp((char *)dir->d_name, header, head_len)) {
min = strlen(dirname) + 1;
if (min > sizeof(temp_fname))
min = sizeof(temp_fname) - 1;
memset(temp_fname, 0, sizeof(temp_fname));
memcpy(temp_fname, dirname, min);
min = sizeof(temp_fname) - min;
if (min > 1)
strncat(temp_fname, dir->d_name, min);
else {
pr_err("rdr:file path is too long!\n");
kfree(buf);
return -1;
}
p_dname = dir->d_name + head_len;
for (j = 0; j < sizeof(str2int_buf); j++) {
if ((*p_dname == '\0') || (*p_dname > '9') ||
(*p_dname < '0')) {
str2int_buf[j] = '\0';
break;
}
str2int_buf[j] = *p_dname;
p_dname++;
}
if (kstrtoint(str2int_buf, 10, &index)) {
DUMP_LOG((int)index);
kfree(buf);
return -1;
}
if ((index >= RDR_FILE_MAX_CNT - 1)
|| (0 != fname[index][0])) {
if (sys_unlink(temp_fname)) {
DUMP_LOG(0);
kfree(buf);
return -1;
}
} else
strncpy(fname[index], temp_fname,
RDR_FNAME_LEN);
}
}
for (i = RDR_FILE_MAX_CNT - 2; i >= 0; i--) { /* rename file: */
if (fname[i][0]) {
snprintf(temp_fname, sizeof(temp_fname),
"%s%s%02d.bin", dirname, file_header, i + 1);
if (sys_rename(fname[i], temp_fname)) {
DUMP_LOG(0);
kfree(buf);
return -1;
}
}
}
kfree(buf);
return 0;
}
void rdr_upload(char *path, char *timedir, char *ecore)
{
int ret, i;
mm_segment_t old_fs;
struct kstat m_stat;
char dst[RDR_FNAME_LEN] = {0};
char fn[RDR_FNAME_LEN];
int rdrbin_tag = 0;
char *name_tab;
size_t tab_siz;
char *pn;
char rgz[RDR_FNAME_LEN];
if (path == NULL)
return;
old_fs = get_fs();
set_fs(KERNEL_DS);
/* check path , if path isnt exist, return. */
ret = vfs_stat(path, &m_stat);
if (ret) {
rdr_debug("dir not exist, dont upload and archive");
goto out;
}
/* check rdr/rdx/dfx, select the best one, delete others. */
snprintf(dst, sizeof(dst), "%s%s/", path, timedir);
ret = vfs_stat(dst, &m_stat);
if (ret) {
rdr_debug("dir %s not exist", dst);
goto out;
}
rdr_dir_list(dst, NULL, 0, 0, &ret, DT_REG);
if (ret > 1) {
tab_siz = ret * RDR_RGZNAME_SZ;
rdr_debug("the files in %s dir :%d", dst, ret);
name_tab = vmalloc(tab_siz);
if (name_tab == NULL) {
pr_err("rdr:%s():name_tab alloc fail.\n", __func__);
goto out;
}
memset(name_tab, 0, tab_siz);
rdr_dir_list(dst, (rdr_funcptr_3)rdr_get_8m_name,
(u64)name_tab, (u64)ret, (int *)0, DT_REG);
for (i = 0; i < ret; i++) {
pn = name_tab + i * RDR_RGZNAME_SZ;
if (*pn == '\0')
break;
if (!strncmp("rdr.bin", pn, 7)) {
pr_info("rdr:find rdr.bin, del other bin\n");
snprintf(fn, sizeof(fn), "%srdx.bin", dst);
sys_unlink(fn);
snprintf(fn, sizeof(fn), "%sdfx.bin", dst);
sys_unlink(fn);
rdrbin_tag = 1;
break;
}
}
if (rdrbin_tag == 0) {
for (i = 0; i < ret; i++) {
pn = name_tab + i * RDR_RGZNAME_SZ;
if (*pn == '\0')
break;
if (!strncmp("dfx.bin", pn, 7)) {
pr_info("rdr:find dfx.bin,rm others\n");
snprintf(fn, sizeof(fn), "%srdx.bin", dst);
sys_unlink(fn);
break;
}
}
}
vfree(name_tab);
}
memset(rgz, 0, sizeof(rgz));
/* zip or upload it. */
#ifdef CONFIG_SRECORDER
rdr_zip_dir(dst, rgz, sizeof(rgz));
rdr_create_dir(SRECORDER_PATH);
rdr_debug("rgz:%s", rgz);
ret = sys_rename(rgz, SRECORDER_FILE);
if (ret < 0)
pr_err("rdr:rename %s to %s failed\n", rgz, SRECORDER_FILE);
#else
if ((ecore != NULL) &&
(!strncmp(ecore, RDR_STR_CORE_CP, strlen(RDR_STR_CORE_CP)))) {
rdr_zip_dir(dst, rgz, sizeof(rgz));
snprintf(fn, sizeof(fn), "%sup/cp.rgz", OM_ROOT_PATH);
rdr_create_dir(fn);
sys_unlink(fn);
ret = sys_rename(rgz, fn);
if (ret < 0)
pr_err("rdr:rename %s to %s failed\n", rgz, fn);
else
pr_info("rdr:mv from %s to %s OK\n", rgz, fn);
}
rdr_up2apr(dst, ecore);
#endif
/* if the file counts of path dir over 3, delete it. */
rdr_rm_over3_file(path);
out:
set_fs(old_fs);
}
