2010-07-22 09:08:17 -07:00
|
|
|
/* EIO - EFL data type library
|
|
|
|
* Copyright (C) 2010 Enlightenment Developers:
|
|
|
|
* Cedric Bail <cedric.bail@free.fr>
|
|
|
|
* Vincent "caro" Torri <vtorri at univ-evry dot fr>
|
2010-07-28 15:12:41 -07:00
|
|
|
* Stephen "okra" Houston <UnixTitan@gmail.com>
|
2010-07-22 09:08:17 -07:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library;
|
|
|
|
* if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
2010-10-27 05:30:12 -07:00
|
|
|
|
2010-08-31 09:24:58 -07:00
|
|
|
#include "eio_private.h"
|
|
|
|
#include "Eio.h"
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2011-04-28 09:45:45 -07:00
|
|
|
#ifdef HAVE_XATTR
|
|
|
|
# include <sys/xattr.h>
|
|
|
|
#endif
|
|
|
|
|
2010-10-20 12:17:30 -07:00
|
|
|
/*============================================================================*
|
|
|
|
* Local *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
|
|
|
|
2010-07-22 09:08:17 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_heavy(void *data, Ecore_Thread *thread)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-08-03 10:11:44 -07:00
|
|
|
Eio_File_Char_Ls *async = data;
|
2010-07-23 04:00:44 -07:00
|
|
|
Eina_Iterator *ls;
|
2010-07-22 09:08:17 -07:00
|
|
|
const char *file;
|
2011-07-02 04:06:52 -07:00
|
|
|
Eina_List *pack = NULL;
|
|
|
|
double start, current;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
ls = eina_file_ls(async->ls.directory);
|
|
|
|
if (!ls)
|
|
|
|
{
|
2010-10-13 10:46:02 -07:00
|
|
|
eio_file_thread_error(&async->ls.common, thread);
|
2010-07-23 04:00:44 -07:00
|
|
|
return ;
|
|
|
|
}
|
|
|
|
|
2011-05-24 03:41:37 -07:00
|
|
|
eio_file_container_set(&async->ls.common, eina_iterator_container_get(ls));
|
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
start = ecore_time_get();
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
EINA_ITERATOR_FOREACH(ls, file)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
|
|
|
Eina_Bool filter = EINA_TRUE;
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
if (async->filter_cb)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-11-12 06:08:01 -08:00
|
|
|
filter = async->filter_cb((void*) async->ls.common.data, &async->ls.common, file);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
2011-06-07 09:30:10 -07:00
|
|
|
if (filter)
|
|
|
|
{
|
2012-03-30 23:30:08 -07:00
|
|
|
Eio_File_Char *send_fc;
|
2011-06-07 09:30:10 -07:00
|
|
|
|
2012-03-30 23:30:08 -07:00
|
|
|
send_fc = eio_char_malloc();
|
|
|
|
if (!send_fc) goto on_error;
|
2011-06-07 09:30:10 -07:00
|
|
|
|
2012-03-30 23:30:08 -07:00
|
|
|
send_fc->filename = file;
|
|
|
|
send_fc->associated = async->ls.common.worker.associated;
|
2011-06-07 09:30:10 -07:00
|
|
|
async->ls.common.worker.associated = NULL;
|
|
|
|
|
2012-03-30 23:30:08 -07:00
|
|
|
pack = eina_list_append(pack, send_fc);
|
2011-06-07 09:30:10 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
on_error:
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
|
|
|
|
if (async->ls.common.worker.associated)
|
|
|
|
{
|
|
|
|
eina_hash_free(async->ls.common.worker.associated);
|
|
|
|
async->ls.common.worker.associated = NULL;
|
|
|
|
}
|
|
|
|
}
|
2010-07-23 04:00:44 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
current = ecore_time_get();
|
|
|
|
if (current - start > EIO_PACKED_TIME)
|
|
|
|
{
|
|
|
|
start = current;
|
|
|
|
ecore_thread_feedback(thread, pack);
|
|
|
|
pack = NULL;
|
|
|
|
}
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
break;
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
2010-07-23 04:00:44 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
if (pack) ecore_thread_feedback(thread, pack);
|
|
|
|
|
2011-05-24 03:41:37 -07:00
|
|
|
eio_file_container_set(&async->ls.common, NULL);
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
eina_iterator_free(ls);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_notify(void *data, Ecore_Thread *thread __UNUSED__, void *msg_data)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-08-03 10:11:44 -07:00
|
|
|
Eio_File_Char_Ls *async = data;
|
2011-07-02 04:06:52 -07:00
|
|
|
Eina_List *pack = msg_data;
|
|
|
|
Eio_File_Char *info;
|
2011-06-07 09:30:10 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
EINA_LIST_FREE(pack, info)
|
|
|
|
{
|
|
|
|
async->ls.common.main.associated = info->associated;
|
2011-06-07 09:30:10 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
async->main_cb((void*) async->ls.common.data,
|
|
|
|
&async->ls.common,
|
|
|
|
info->filename);
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
if (async->ls.common.main.associated)
|
|
|
|
{
|
|
|
|
eina_hash_free(async->ls.common.main.associated);
|
|
|
|
async->ls.common.main.associated = NULL;
|
|
|
|
}
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
eina_stringshare_del(info->filename);
|
|
|
|
eio_char_free(info);
|
|
|
|
}
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-02 10:08:00 -07:00
|
|
|
_eio_file_eina_ls_heavy(Ecore_Thread *thread, Eio_File_Direct_Ls *async, Eina_Iterator *ls)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
|
|
|
const Eina_File_Direct_Info *info;
|
2011-07-02 04:06:52 -07:00
|
|
|
Eina_List *pack = NULL;
|
|
|
|
double start, current;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
if (!ls)
|
|
|
|
{
|
2010-10-13 10:46:02 -07:00
|
|
|
eio_file_thread_error(&async->ls.common, thread);
|
2010-07-23 04:00:44 -07:00
|
|
|
return ;
|
|
|
|
}
|
|
|
|
|
2011-05-24 03:41:37 -07:00
|
|
|
eio_file_container_set(&async->ls.common, eina_iterator_container_get(ls));
|
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
start = ecore_time_get();
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
EINA_ITERATOR_FOREACH(ls, info)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
|
|
|
Eina_Bool filter = EINA_TRUE;
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
if (async->filter_cb)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-11-12 06:08:01 -08:00
|
|
|
filter = async->filter_cb((void*) async->ls.common.data, &async->ls.common, info);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (filter)
|
|
|
|
{
|
2012-03-30 23:30:08 -07:00
|
|
|
Eio_File_Direct_Info *send_di;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2012-03-30 23:30:08 -07:00
|
|
|
send_di = eio_direct_info_malloc();
|
|
|
|
if (!send_di) continue;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2012-03-30 23:30:08 -07:00
|
|
|
memcpy(&send_di->info, info, sizeof (Eina_File_Direct_Info));
|
|
|
|
send_di->associated = async->ls.common.worker.associated;
|
2011-06-07 09:30:10 -07:00
|
|
|
async->ls.common.worker.associated = NULL;
|
2010-10-05 04:44:03 -07:00
|
|
|
|
2012-03-30 23:30:08 -07:00
|
|
|
pack = eina_list_append(pack, send_di);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
2011-06-07 09:30:10 -07:00
|
|
|
else if (async->ls.common.worker.associated)
|
|
|
|
{
|
|
|
|
eina_hash_free(async->ls.common.worker.associated);
|
|
|
|
async->ls.common.worker.associated = NULL;
|
|
|
|
}
|
2010-07-23 04:00:44 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
current = ecore_time_get();
|
|
|
|
if (current - start > EIO_PACKED_TIME)
|
|
|
|
{
|
|
|
|
start = current;
|
|
|
|
ecore_thread_feedback(thread, pack);
|
|
|
|
pack = NULL;
|
|
|
|
}
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
break;
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
2010-07-23 04:00:44 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
if (pack) ecore_thread_feedback(thread, pack);
|
|
|
|
|
2011-05-24 03:41:37 -07:00
|
|
|
eio_file_container_set(&async->ls.common, NULL);
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
eina_iterator_free(ls);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
2010-11-02 10:08:00 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_direct_heavy(void *data, Ecore_Thread *thread)
|
2010-11-02 10:08:00 -07:00
|
|
|
{
|
|
|
|
Eio_File_Direct_Ls *async = data;
|
|
|
|
Eina_Iterator *ls;
|
|
|
|
|
|
|
|
ls = eina_file_direct_ls(async->ls.directory);
|
|
|
|
|
|
|
|
_eio_file_eina_ls_heavy(thread, async, ls);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_stat_heavy(void *data, Ecore_Thread *thread)
|
2010-11-02 10:08:00 -07:00
|
|
|
{
|
|
|
|
Eio_File_Direct_Ls *async = data;
|
|
|
|
Eina_Iterator *ls;
|
|
|
|
|
|
|
|
ls = eina_file_stat_ls(async->ls.directory);
|
|
|
|
|
|
|
|
_eio_file_eina_ls_heavy(thread, async, ls);
|
|
|
|
}
|
|
|
|
|
2010-07-22 09:08:17 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_direct_notify(void *data, Ecore_Thread *thread __UNUSED__, void *msg_data)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-08-03 10:59:55 -07:00
|
|
|
Eio_File_Direct_Ls *async = data;
|
2011-07-02 04:06:52 -07:00
|
|
|
Eina_List *pack = msg_data;
|
|
|
|
Eio_File_Direct_Info *info;
|
2011-06-07 09:30:10 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
EINA_LIST_FREE(pack, info)
|
|
|
|
{
|
|
|
|
async->ls.common.main.associated = info->associated;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
async->main_cb((void*) async->ls.common.data,
|
|
|
|
&async->ls.common,
|
|
|
|
&info->info);
|
2011-06-07 09:30:10 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
if (async->ls.common.main.associated)
|
|
|
|
{
|
|
|
|
eina_hash_free(async->ls.common.main.associated);
|
|
|
|
async->ls.common.main.associated = NULL;
|
|
|
|
}
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2011-07-02 04:06:52 -07:00
|
|
|
eio_direct_info_free(info);
|
|
|
|
}
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
2012-01-03 07:00:30 -08:00
|
|
|
static void
|
2012-04-03 06:34:04 -07:00
|
|
|
_eio_eina_file_copy_xattr(Ecore_Thread *thread __UNUSED__,
|
|
|
|
Eio_File_Progress *op __UNUSED__,
|
|
|
|
Eina_File *f, int out)
|
2012-01-03 07:00:30 -08:00
|
|
|
{
|
|
|
|
Eina_Iterator *it;
|
|
|
|
Eina_Xattr *attr;
|
|
|
|
|
|
|
|
it = eina_file_xattr_value_get(f);
|
|
|
|
EINA_ITERATOR_FOREACH(it, attr)
|
|
|
|
{
|
2012-04-03 06:34:04 -07:00
|
|
|
#ifdef HAVE_XATTR
|
2012-01-03 07:00:30 -08:00
|
|
|
fsetxattr(out, attr->name, attr->value, attr->length, 0);
|
2012-04-03 06:34:04 -07:00
|
|
|
#endif
|
2012-01-03 07:00:30 -08:00
|
|
|
}
|
|
|
|
eina_iterator_free(it);
|
|
|
|
}
|
|
|
|
|
2012-04-03 06:34:04 -07:00
|
|
|
#ifdef HAVE_XATTR
|
2011-04-28 09:45:45 -07:00
|
|
|
static void
|
2011-06-07 09:30:10 -07:00
|
|
|
_eio_file_copy_xattr(Ecore_Thread *thread __UNUSED__,
|
|
|
|
Eio_File_Progress *op __UNUSED__,
|
|
|
|
int in, int out)
|
2011-04-28 09:45:45 -07:00
|
|
|
{
|
|
|
|
char *tmp;
|
|
|
|
ssize_t length;
|
|
|
|
ssize_t i;
|
|
|
|
|
|
|
|
length = flistxattr(in, NULL, 0);
|
|
|
|
|
2011-05-03 03:36:51 -07:00
|
|
|
if (length <= 0) return ;
|
2011-04-28 09:45:45 -07:00
|
|
|
|
|
|
|
tmp = alloca(length);
|
|
|
|
length = flistxattr(in, tmp, length);
|
|
|
|
|
|
|
|
for (i = 0; i < length; i += strlen(tmp) + 1)
|
|
|
|
{
|
|
|
|
ssize_t attr_length;
|
|
|
|
void *value;
|
|
|
|
|
|
|
|
attr_length = fgetxattr(in, tmp, NULL, 0);
|
|
|
|
if (!attr_length) continue ;
|
|
|
|
|
|
|
|
value = malloc(attr_length);
|
|
|
|
if (!value) continue ;
|
|
|
|
attr_length = fgetxattr(in, tmp, value, attr_length);
|
|
|
|
|
|
|
|
if (attr_length > 0)
|
|
|
|
fsetxattr(out, tmp, value, attr_length, 0);
|
|
|
|
|
|
|
|
free(value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_eio_file_write(int fd, void *mem, ssize_t length)
|
|
|
|
{
|
|
|
|
ssize_t count;
|
|
|
|
|
|
|
|
if (length == 0) return EINA_TRUE;
|
|
|
|
|
|
|
|
count = write(fd, mem, length);
|
|
|
|
if (count != length) return EINA_FALSE;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef MAP_HUGETLB
|
|
|
|
# define MAP_HUGETLB 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static Eina_Bool
|
2012-01-18 07:45:01 -08:00
|
|
|
_eio_file_copy_mmap(Ecore_Thread *thread, Eio_File_Progress *op, Eina_File *f, int out)
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
{
|
|
|
|
char *m = MAP_FAILED;
|
2011-03-09 06:53:55 -08:00
|
|
|
long long i;
|
2012-01-18 07:45:01 -08:00
|
|
|
long long size;
|
|
|
|
|
|
|
|
size = eina_file_size_get(f);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
|
|
|
for (i = 0; i < size; i += EIO_PACKET_SIZE * EIO_PACKET_COUNT)
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
int k;
|
|
|
|
int c;
|
|
|
|
|
2012-01-03 07:00:30 -08:00
|
|
|
m = eina_file_map_new(f, EINA_FILE_SEQUENTIAL,
|
|
|
|
i, EIO_PACKET_SIZE * EIO_PACKET_COUNT);
|
|
|
|
if (!m)
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
c = size - i;
|
|
|
|
if (c - EIO_PACKET_SIZE * EIO_PACKET_COUNT > 0)
|
|
|
|
c = EIO_PACKET_SIZE * EIO_PACKET_COUNT;
|
|
|
|
else
|
|
|
|
c = size - i;
|
|
|
|
|
|
|
|
for (j = EIO_PACKET_SIZE, k = 0; j < c; k = j, j += EIO_PACKET_SIZE)
|
|
|
|
{
|
|
|
|
if (!_eio_file_write(out, m + k, EIO_PACKET_SIZE))
|
|
|
|
goto on_error;
|
|
|
|
|
2010-10-05 05:56:07 -07:00
|
|
|
eio_progress_send(thread, op, i + j, size);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!_eio_file_write(out, m + k, c - k))
|
|
|
|
goto on_error;
|
|
|
|
|
2012-01-03 07:00:30 -08:00
|
|
|
if (eina_file_map_faulted(f, m))
|
|
|
|
goto on_error;
|
|
|
|
|
2010-10-05 05:56:07 -07:00
|
|
|
eio_progress_send(thread, op, i + c, size);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
2012-01-03 07:00:30 -08:00
|
|
|
eina_file_map_free(f, m);
|
|
|
|
m = NULL;
|
2010-10-05 05:56:07 -07:00
|
|
|
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
goto on_error;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
on_error:
|
2012-01-03 07:00:30 -08:00
|
|
|
if (m != NULL) eina_file_map_free(f, m);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2012-03-25 12:15:44 -07:00
|
|
|
#ifdef HAVE_SPLICE
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
static int
|
2011-03-09 06:53:55 -08:00
|
|
|
_eio_file_copy_splice(Ecore_Thread *thread, Eio_File_Progress *op, int in, int out, long long size)
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
{
|
|
|
|
int result = 0;
|
2011-03-09 06:53:55 -08:00
|
|
|
long long count;
|
|
|
|
long long i;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
int pipefd[2];
|
|
|
|
|
|
|
|
if (pipe(pipefd) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i += count)
|
|
|
|
{
|
|
|
|
count = splice(in, 0, pipefd[1], NULL, EIO_PACKET_SIZE * EIO_PACKET_COUNT, SPLICE_F_MORE | SPLICE_F_MOVE);
|
|
|
|
if (count < 0) goto on_error;
|
|
|
|
|
|
|
|
count = splice(pipefd[0], NULL, out, 0, count, SPLICE_F_MORE | SPLICE_F_MOVE);
|
|
|
|
if (count < 0) goto on_error;
|
|
|
|
|
2010-10-05 05:56:07 -07:00
|
|
|
eio_progress_send(thread, op, i, size);
|
|
|
|
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
goto on_error;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
result = 1;
|
|
|
|
|
|
|
|
on_error:
|
|
|
|
if (result != 1 && (errno == EBADF || errno == EINVAL)) result = -1;
|
|
|
|
close(pipefd[0]);
|
|
|
|
close(pipefd[1]);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-10-05 07:55:47 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_copy_heavy(void *data, Ecore_Thread *thread)
|
2010-10-05 07:55:47 -07:00
|
|
|
{
|
|
|
|
Eio_File_Progress *copy = data;
|
|
|
|
|
|
|
|
eio_file_copy_do(thread, copy);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_copy_notify(void *data, Ecore_Thread *thread __UNUSED__, void *msg_data)
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
{
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
Eio_File_Progress *copy = data;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
2010-10-05 08:32:24 -07:00
|
|
|
eio_progress_cb(msg_data, copy);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
}
|
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
static void
|
|
|
|
_eio_file_copy_free(Eio_File_Progress *copy)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(copy->source);
|
|
|
|
eina_stringshare_del(copy->dest);
|
|
|
|
free(copy);
|
|
|
|
}
|
|
|
|
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_copy_end(void *data, Ecore_Thread *thread __UNUSED__)
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
{
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
Eio_File_Progress *copy = data;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
2010-11-12 06:08:01 -08:00
|
|
|
copy->common.done_cb((void*) copy->common.data, ©->common);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_file_copy_free(copy);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_copy_error(void *data, Ecore_Thread *thread __UNUSED__)
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
{
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
Eio_File_Progress *copy = data;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
|
|
|
eio_file_error(©->common);
|
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_file_copy_free(copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_file_move_free(Eio_File_Move *move)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(move->progress.source);
|
|
|
|
eina_stringshare_del(move->progress.dest);
|
|
|
|
free(move);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
}
|
|
|
|
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
static void
|
2010-11-12 06:08:01 -08:00
|
|
|
_eio_file_move_copy_progress(void *data, Eio_File *handler __UNUSED__, const Eio_Progress *info)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
2010-11-12 06:08:01 -08:00
|
|
|
move->progress.progress_cb((void*) move->progress.common.data, &move->progress.common, info);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 06:08:01 -08:00
|
|
|
_eio_file_move_unlink_done(void *data, Eio_File *handler __UNUSED__)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
2010-11-12 06:08:01 -08:00
|
|
|
move->progress.common.done_cb((void*) move->progress.common.data, &move->progress.common);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_file_move_free(move);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 06:08:01 -08:00
|
|
|
_eio_file_move_unlink_error(void *data, Eio_File *handler __UNUSED__, int error)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
|
|
|
move->copy = NULL;
|
|
|
|
|
|
|
|
move->progress.common.error = error;
|
|
|
|
eio_file_error(&move->progress.common);
|
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_file_move_free(move);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 06:08:01 -08:00
|
|
|
_eio_file_move_copy_done(void *data, Eio_File *handler __UNUSED__)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
Eio_File *rm;
|
|
|
|
|
|
|
|
rm = eio_file_unlink(move->progress.source,
|
|
|
|
_eio_file_move_unlink_done,
|
|
|
|
_eio_file_move_unlink_error,
|
|
|
|
move);
|
|
|
|
if (rm) move->copy = rm;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 06:08:01 -08:00
|
|
|
_eio_file_move_copy_error(void *data, Eio_File *handler __UNUSED__, int error)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
|
|
|
move->progress.common.error = error;
|
|
|
|
eio_file_error(&move->progress.common);
|
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_file_move_free(move);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_move_heavy(void *data, Ecore_Thread *thread)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
|
|
|
if (rename(move->progress.source, move->progress.dest) < 0)
|
2010-10-13 10:46:02 -07:00
|
|
|
eio_file_thread_error(&move->progress.common, thread);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
else
|
2010-10-05 05:56:07 -07:00
|
|
|
eio_progress_send(thread, &move->progress, 1, 1);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_move_notify(void *data, Ecore_Thread *thread __UNUSED__, void *msg_data)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
2010-10-05 08:32:24 -07:00
|
|
|
eio_progress_cb(msg_data, &move->progress);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_move_end(void *data, Ecore_Thread *thread __UNUSED__)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
2010-11-12 06:08:01 -08:00
|
|
|
move->progress.common.done_cb((void*) move->progress.common.data, &move->progress.common);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_file_move_free(move);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_file_move_error(void *data, Ecore_Thread *thread __UNUSED__)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
|
|
|
if (move->copy)
|
|
|
|
{
|
|
|
|
eio_file_cancel(move->copy);
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
|
2010-10-05 07:29:58 -07:00
|
|
|
if (move->progress.common.error == EXDEV)
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
{
|
|
|
|
Eio_File *eio_cp;
|
|
|
|
|
|
|
|
eio_cp = eio_file_copy(move->progress.source, move->progress.dest,
|
|
|
|
move->progress.progress_cb ? _eio_file_move_copy_progress : NULL,
|
|
|
|
_eio_file_move_copy_done,
|
|
|
|
_eio_file_move_copy_error,
|
|
|
|
move);
|
|
|
|
|
2010-10-05 04:44:03 -07:00
|
|
|
if (eio_cp)
|
|
|
|
{
|
|
|
|
move->copy = eio_cp;
|
|
|
|
|
|
|
|
move->progress.common.thread = ((Eio_File_Progress*)move->copy)->common.thread;
|
|
|
|
return ;
|
|
|
|
}
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
eio_file_error(&move->progress.common);
|
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_file_move_free(move);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
}
|
|
|
|
|
2010-10-20 12:17:30 -07:00
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*============================================================================*
|
|
|
|
* Global *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
eio_progress_cb(Eio_Progress *progress, Eio_File_Progress *op)
|
|
|
|
{
|
2010-11-12 06:08:01 -08:00
|
|
|
op->progress_cb((void *) op->common.data, &op->common, progress);
|
2010-10-20 12:17:30 -07:00
|
|
|
|
|
|
|
eio_progress_free(progress);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
eio_file_copy_do(Ecore_Thread *thread, Eio_File_Progress *copy)
|
|
|
|
{
|
2012-01-03 07:00:30 -08:00
|
|
|
Eina_File *f;
|
2012-03-25 12:15:44 -07:00
|
|
|
#ifdef HAVE_SPLICE
|
2010-10-20 12:17:30 -07:00
|
|
|
struct stat buf;
|
|
|
|
int in = -1;
|
2012-01-03 07:00:30 -08:00
|
|
|
#endif
|
2012-01-18 07:45:01 -08:00
|
|
|
mode_t md;
|
2012-01-03 07:00:30 -08:00
|
|
|
int result = -1;
|
2010-10-20 12:17:30 -07:00
|
|
|
int out = -1;
|
|
|
|
|
2012-03-25 12:15:44 -07:00
|
|
|
#ifdef HAVE_SPLICE
|
2010-10-20 12:17:30 -07:00
|
|
|
in = open(copy->source, O_RDONLY);
|
|
|
|
if (in < 0)
|
|
|
|
{
|
|
|
|
eio_file_thread_error(©->common, thread);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
As we need file size for progression information and both copy method
|
|
|
|
call fstat (better than stat as it avoid race condition).
|
|
|
|
*/
|
|
|
|
if (fstat(in, &buf) < 0)
|
|
|
|
goto on_error;
|
2012-01-18 07:45:01 -08:00
|
|
|
|
|
|
|
md = buf.st_mode;
|
2012-01-03 07:00:30 -08:00
|
|
|
#endif
|
2010-10-20 12:17:30 -07:00
|
|
|
|
|
|
|
/* open write */
|
2012-01-20 08:08:10 -08:00
|
|
|
out = open(copy->dest, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
|
2010-10-20 12:17:30 -07:00
|
|
|
if (out < 0)
|
|
|
|
goto on_error;
|
|
|
|
|
2012-03-25 12:15:44 -07:00
|
|
|
#ifdef HAVE_SPLICE
|
2010-10-20 12:17:30 -07:00
|
|
|
/* fast file copy code using Linux splice API */
|
|
|
|
result = _eio_file_copy_splice(thread, copy, in, out, buf.st_size);
|
|
|
|
if (result == 0)
|
|
|
|
goto on_error;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* classic copy method using mmap and write */
|
2012-01-03 07:00:30 -08:00
|
|
|
if (result == -1)
|
|
|
|
{
|
2012-03-25 12:15:44 -07:00
|
|
|
#ifndef HAVE_SPLICE
|
2012-01-18 07:45:01 -08:00
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
if (stat(copy->source, &buf) < 0)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
md = buf.st_mode;
|
|
|
|
#endif
|
|
|
|
|
2012-01-03 07:00:30 -08:00
|
|
|
f = eina_file_open(copy->source, 0);
|
|
|
|
if (!f) goto on_error;
|
|
|
|
|
2012-01-18 07:45:01 -08:00
|
|
|
if (!_eio_file_copy_mmap(thread, copy, f, out))
|
2012-01-03 07:00:30 -08:00
|
|
|
{
|
|
|
|
eina_file_close(f);
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
|
2012-04-03 06:34:04 -07:00
|
|
|
_eio_eina_file_copy_xattr(thread, copy, f, out);
|
2012-01-03 07:00:30 -08:00
|
|
|
|
|
|
|
eina_file_close(f);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
#ifdef HAVE_XATTR
|
|
|
|
_eio_file_copy_xattr(thread, copy, in, out);
|
|
|
|
#endif
|
|
|
|
}
|
2010-10-20 12:17:30 -07:00
|
|
|
|
|
|
|
/* change access right to match source */
|
2010-10-21 10:51:21 -07:00
|
|
|
#ifdef HAVE_CHMOD
|
2012-01-18 07:45:01 -08:00
|
|
|
if (fchmod(out, md) != 0)
|
2010-10-20 12:17:30 -07:00
|
|
|
goto on_error;
|
2010-10-21 10:51:21 -07:00
|
|
|
#else
|
2012-01-18 07:45:01 -08:00
|
|
|
if (chmod(copy->dest, md) != 0)
|
2010-10-21 10:51:21 -07:00
|
|
|
goto on_error;
|
|
|
|
#endif
|
2010-10-20 12:17:30 -07:00
|
|
|
|
|
|
|
close(out);
|
2012-03-25 12:15:44 -07:00
|
|
|
#ifdef HAVE_SPLICE
|
2010-10-20 12:17:30 -07:00
|
|
|
close(in);
|
2012-01-03 07:00:30 -08:00
|
|
|
#endif
|
2010-10-20 12:17:30 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
on_error:
|
|
|
|
eio_file_thread_error(©->common, thread);
|
|
|
|
|
2012-03-25 12:15:44 -07:00
|
|
|
#ifdef HAVE_SPLICE
|
2010-10-20 12:17:30 -07:00
|
|
|
if (in >= 0) close(in);
|
2012-01-18 07:45:01 -08:00
|
|
|
#endif
|
2010-10-20 12:17:30 -07:00
|
|
|
if (out >= 0) close(out);
|
|
|
|
if (out >= 0)
|
|
|
|
unlink(copy->dest);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2011-05-03 03:36:51 -07:00
|
|
|
void
|
|
|
|
eio_async_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Eio_File_Ls *async = data;
|
|
|
|
|
|
|
|
async->common.done_cb((void*) async->common.data, &async->common);
|
|
|
|
|
|
|
|
eina_stringshare_del(async->directory);
|
|
|
|
free(async);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
eio_async_error(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Eio_File_Ls *async = data;
|
|
|
|
|
|
|
|
eio_file_error(&async->common);
|
|
|
|
|
|
|
|
eina_stringshare_del(async->directory);
|
|
|
|
free(async);
|
|
|
|
}
|
|
|
|
|
2010-10-20 12:17:30 -07:00
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*============================================================================*
|
|
|
|
* API *
|
|
|
|
*============================================================================*/
|
2010-10-12 07:59:30 -07:00
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
EAPI Eio_File *
|
2010-07-22 09:08:17 -07:00
|
|
|
eio_file_ls(const char *dir,
|
2010-07-23 04:00:44 -07:00
|
|
|
Eio_Filter_Cb filter_cb,
|
|
|
|
Eio_Main_Cb main_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
2010-09-07 07:43:51 -07:00
|
|
|
Eio_Error_Cb error_cb,
|
2010-07-23 04:00:44 -07:00
|
|
|
const void *data)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-10-08 13:14:21 -07:00
|
|
|
Eio_File_Char_Ls *async;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
2010-08-31 09:24:58 -07:00
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
async = malloc(sizeof (Eio_File_Char_Ls));
|
2010-10-08 13:14:21 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
async->filter_cb = filter_cb;
|
|
|
|
async->main_cb = main_cb;
|
|
|
|
async->ls.directory = eina_stringshare_add(dir);
|
|
|
|
|
2010-09-06 09:37:43 -07:00
|
|
|
if (!eio_long_file_set(&async->ls.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_file_heavy,
|
|
|
|
_eio_file_notify,
|
2011-05-03 03:36:51 -07:00
|
|
|
eio_async_end,
|
|
|
|
eio_async_error))
|
2010-09-06 09:37:43 -07:00
|
|
|
return NULL;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-09-06 09:37:43 -07:00
|
|
|
return &async->ls.common;
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
EAPI Eio_File *
|
2010-07-22 09:08:17 -07:00
|
|
|
eio_file_direct_ls(const char *dir,
|
2010-07-23 04:00:44 -07:00
|
|
|
Eio_Filter_Direct_Cb filter_cb,
|
|
|
|
Eio_Main_Direct_Cb main_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
2010-09-07 07:43:51 -07:00
|
|
|
Eio_Error_Cb error_cb,
|
2010-07-23 04:00:44 -07:00
|
|
|
const void *data)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-10-08 13:14:21 -07:00
|
|
|
Eio_File_Direct_Ls *async;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
2010-08-31 09:24:58 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
async = malloc(sizeof(Eio_File_Direct_Ls));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
async->filter_cb = filter_cb;
|
|
|
|
async->main_cb = main_cb;
|
|
|
|
async->ls.directory = eina_stringshare_add(dir);
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-09-06 09:37:43 -07:00
|
|
|
if (!eio_long_file_set(&async->ls.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_file_direct_heavy,
|
|
|
|
_eio_file_direct_notify,
|
2011-05-03 03:36:51 -07:00
|
|
|
eio_async_end,
|
|
|
|
eio_async_error))
|
2010-09-06 09:37:43 -07:00
|
|
|
return NULL;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-09-06 09:37:43 -07:00
|
|
|
return &async->ls.common;
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
2010-11-02 10:08:00 -07:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_file_stat_ls(const char *dir,
|
|
|
|
Eio_Filter_Direct_Cb filter_cb,
|
|
|
|
Eio_Main_Direct_Cb main_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
|
|
|
Eio_File_Direct_Ls *async;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
|
|
|
|
|
|
|
async = malloc(sizeof(Eio_File_Direct_Ls));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
|
|
|
|
|
|
|
|
async->filter_cb = filter_cb;
|
|
|
|
async->main_cb = main_cb;
|
|
|
|
async->ls.directory = eina_stringshare_add(dir);
|
|
|
|
|
|
|
|
if (!eio_long_file_set(&async->ls.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_file_stat_heavy,
|
|
|
|
_eio_file_direct_notify,
|
2011-05-03 03:36:51 -07:00
|
|
|
eio_async_end,
|
|
|
|
eio_async_error))
|
2010-11-02 10:08:00 -07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &async->ls.common;
|
|
|
|
}
|
|
|
|
|
2010-07-22 09:08:17 -07:00
|
|
|
EAPI Eina_Bool
|
2010-07-23 04:00:44 -07:00
|
|
|
eio_file_cancel(Eio_File *ls)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-10-08 13:14:21 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(ls, EINA_FALSE);
|
2010-07-23 04:00:44 -07:00
|
|
|
return ecore_thread_cancel(ls->thread);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
2011-06-25 15:49:01 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
eio_file_check(Eio_File *ls)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(ls, EINA_TRUE);
|
|
|
|
return ecore_thread_check(ls->thread);
|
|
|
|
}
|
|
|
|
|
2011-05-24 03:41:37 -07:00
|
|
|
EAPI void *
|
|
|
|
eio_file_container_get(Eio_File *ls)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(ls, EINA_FALSE);
|
|
|
|
return ls->container;
|
|
|
|
}
|
|
|
|
|
2011-06-07 09:30:10 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
eio_file_associate_add(Eio_File *ls,
|
|
|
|
const char *key,
|
2011-06-23 06:29:45 -07:00
|
|
|
const void *data, Eina_Free_Cb free_cb)
|
2011-06-07 09:30:10 -07:00
|
|
|
{
|
|
|
|
/* FIXME: Check if we are in the right worker thred */
|
|
|
|
if (!ls->worker.associated)
|
|
|
|
ls->worker.associated = eina_hash_string_small_new(eio_associate_free);
|
|
|
|
|
|
|
|
return eina_hash_add(ls->worker.associated,
|
|
|
|
key,
|
|
|
|
eio_associate_malloc(data, free_cb));
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
eio_file_associate_direct_add(Eio_File *ls,
|
|
|
|
const char *key,
|
2011-06-23 06:29:45 -07:00
|
|
|
const void *data, Eina_Free_Cb free_cb)
|
2011-06-07 09:30:10 -07:00
|
|
|
{
|
|
|
|
/* FIXME: Check if we are in the right worker thred */
|
|
|
|
if (!ls->worker.associated)
|
|
|
|
ls->worker.associated = eina_hash_string_small_new(eio_associate_free);
|
|
|
|
|
|
|
|
return eina_hash_direct_add(ls->worker.associated,
|
|
|
|
key,
|
|
|
|
eio_associate_malloc(data, free_cb));
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
|
|
|
eio_file_associate_find(Eio_File *ls, const char *key)
|
|
|
|
{
|
|
|
|
Eio_File_Associate *search;
|
|
|
|
|
|
|
|
if (!ls->main.associated)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
search = eina_hash_find(ls->main.associated, key);
|
|
|
|
if (!search) return NULL;
|
|
|
|
return search->data;
|
|
|
|
}
|
2011-05-24 03:41:37 -07:00
|
|
|
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_file_copy(const char *source,
|
|
|
|
const char *dest,
|
|
|
|
Eio_Progress_Cb progress_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
2010-10-08 13:14:21 -07:00
|
|
|
Eio_File_Progress *copy;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
copy = malloc(sizeof(Eio_File_Progress));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(copy, NULL);
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
|
2010-10-05 08:32:24 -07:00
|
|
|
copy->op = EIO_FILE_COPY;
|
* eio: add eio_file_copy (using splice when available and
fallback to mmap/write with huge tlb when not).
That what an eio_cp would look like :
#include <Ecore.h>
#include <Eio.h>
static void
_test_progress_cb(void *data, const Eio_Progress *info)
{
printf("%f (%zi / %zi octets)\n", info->percent, info->current, info->max);
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
_test_progress_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52787
2010-09-26 14:47:48 -07:00
|
|
|
copy->progress_cb = progress_cb;
|
|
|
|
copy->source = eina_stringshare_add(source);
|
|
|
|
copy->dest = eina_stringshare_add(dest);
|
|
|
|
|
|
|
|
if (!eio_long_file_set(©->common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_file_copy_heavy,
|
|
|
|
_eio_file_copy_notify,
|
|
|
|
_eio_file_copy_end,
|
|
|
|
_eio_file_copy_error))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return ©->common;
|
|
|
|
}
|
|
|
|
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_file_move(const char *source,
|
|
|
|
const char *dest,
|
|
|
|
Eio_Progress_Cb progress_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
2010-10-08 13:14:21 -07:00
|
|
|
Eio_File_Move *move;
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
move = malloc(sizeof(Eio_File_Move));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(move, NULL);
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
|
2010-10-05 07:55:47 -07:00
|
|
|
move->progress.op = EIO_FILE_MOVE;
|
* eio: add eio_file_move (completly asynchronous and non
blocking move). It first try a rename, then fallback to
an eio_file_copy + eio_file_unlink.
Small example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_done_cb(void *data)
{
printf("move done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_move(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
SVN revision: 52845
2010-09-28 02:05:51 -07:00
|
|
|
move->progress.progress_cb = progress_cb;
|
|
|
|
move->progress.source = eina_stringshare_add(source);
|
|
|
|
move->progress.dest = eina_stringshare_add(dest);
|
|
|
|
move->copy = NULL;
|
|
|
|
|
|
|
|
if (!eio_long_file_set(&move->progress.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_file_move_heavy,
|
|
|
|
_eio_file_move_notify,
|
|
|
|
_eio_file_move_end,
|
|
|
|
_eio_file_move_error))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &move->progress.common;
|
|
|
|
}
|