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-08-31 09:24:58 -07:00
|
|
|
#include "eio_private.h"
|
|
|
|
#include "Eio.h"
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-10-20 12:17:30 -07:00
|
|
|
/*============================================================================*
|
|
|
|
* Local *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
|
|
|
|
2010-07-22 09:08:17 -07:00
|
|
|
static void
|
|
|
|
_eio_file_heavy(Ecore_Thread *thread, void *data)
|
|
|
|
{
|
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;
|
|
|
|
|
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 ;
|
|
|
|
}
|
|
|
|
|
|
|
|
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-09-13 06:44:24 -07:00
|
|
|
filter = async->filter_cb((void*) async->ls.common.data, file);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
2010-09-22 02:47:55 -07:00
|
|
|
if (filter) ecore_thread_feedback(thread, file);
|
2010-07-22 09:08:17 -07:00
|
|
|
else eina_stringshare_del(file);
|
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
|
|
|
|
|
|
|
eina_iterator_free(ls);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-10-05 09:57:51 -07:00
|
|
|
_eio_file_notify(Ecore_Thread *thread __UNUSED__, void *msg_data, void *data)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-08-03 10:11:44 -07:00
|
|
|
Eio_File_Char_Ls *async = data;
|
|
|
|
const char *file = msg_data;
|
2010-07-22 09:08:17 -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
|
|
|
async->main_cb((void*) async->ls.common.data, file);
|
2010-07-22 09:08:17 -07:00
|
|
|
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_file_direct_heavy(Ecore_Thread *thread, void *data)
|
|
|
|
{
|
2010-08-03 10:11:44 -07:00
|
|
|
Eio_File_Direct_Ls *async = data;
|
2010-07-23 04:00:44 -07:00
|
|
|
Eina_Iterator *ls;
|
2010-07-22 09:08:17 -07:00
|
|
|
const Eina_File_Direct_Info *info;
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
ls = eina_file_direct_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 ;
|
|
|
|
}
|
|
|
|
|
|
|
|
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-09-13 06:44:24 -07:00
|
|
|
filter = async->filter_cb((void*) async->ls.common.data, info);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (filter)
|
|
|
|
{
|
|
|
|
Eina_File_Direct_Info *send;
|
|
|
|
|
2010-10-11 05:40:20 -07:00
|
|
|
send = eio_direct_info_malloc();
|
2010-07-22 09:08:17 -07:00
|
|
|
if (!send) continue;
|
|
|
|
|
|
|
|
memcpy(send, info, sizeof (Eina_File_Direct_Info));
|
2010-10-05 04:44:03 -07:00
|
|
|
send->dirent = (struct dirent*)(send + 1);
|
|
|
|
memcpy((void*) send->dirent, info->dirent, sizeof (struct dirent));
|
|
|
|
|
2010-09-22 02:47:55 -07:00
|
|
|
ecore_thread_feedback(thread, send);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
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
|
|
|
|
|
|
|
eina_iterator_free(ls);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-10-05 09:57:51 -07:00
|
|
|
_eio_file_direct_notify(Ecore_Thread *thread __UNUSED__, void *msg_data, void *data)
|
2010-07-22 09:08:17 -07:00
|
|
|
{
|
2010-08-03 10:59:55 -07:00
|
|
|
Eio_File_Direct_Ls *async = data;
|
|
|
|
Eina_File_Direct_Info *info = msg_data;
|
2010-07-22 09:08:17 -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
|
|
|
async->main_cb((void*) async->ls.common.data, info);
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-10-11 05:40:20 -07:00
|
|
|
eio_direct_info_free(info);
|
2010-07-22 09:08:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_file_end(void *data)
|
|
|
|
{
|
2010-08-03 10:59:55 -07:00
|
|
|
Eio_File_Ls *async = data;
|
2010-07-23 04:00:44 -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
|
|
|
async->common.done_cb((void*) async->common.data);
|
2010-07-23 04:00:44 -07:00
|
|
|
|
|
|
|
eina_stringshare_del(async->directory);
|
|
|
|
free(async);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_file_error(void *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_Ls *async = data;
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-09-06 08:27:10 -07:00
|
|
|
eio_file_error(&async->common);
|
2010-07-22 09:08:17 -07:00
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
eina_stringshare_del(async->directory);
|
2010-07-22 09:08:17 -07:00
|
|
|
free(async);
|
|
|
|
}
|
|
|
|
|
* 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
|
* 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_copy_mmap(Ecore_Thread *thread, Eio_File_Progress *op, int in, int out, off_t 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
|
|
|
{
|
|
|
|
char *m = MAP_FAILED;
|
|
|
|
off_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i += EIO_PACKET_SIZE * EIO_PACKET_COUNT)
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
int k;
|
|
|
|
int c;
|
|
|
|
|
|
|
|
m = mmap(NULL, EIO_PACKET_SIZE * EIO_PACKET_COUNT, PROT_READ, MAP_FILE | MAP_HUGETLB | MAP_SHARED, in, i);
|
|
|
|
if (m == MAP_FAILED)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
madvise(m, EIO_PACKET_SIZE * EIO_PACKET_COUNT, MADV_SEQUENTIAL);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
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
|
|
|
|
|
|
|
munmap(m, EIO_PACKET_SIZE * EIO_PACKET_COUNT);
|
|
|
|
m = MAP_FAILED;
|
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:
|
|
|
|
if (m != MAP_FAILED) munmap(m, EIO_PACKET_SIZE * EIO_PACKET_COUNT);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef EFL_HAVE_SPLICE
|
|
|
|
static int
|
* 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_copy_splice(Ecore_Thread *thread, Eio_File_Progress *op, int in, int out, off_t 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;
|
|
|
|
off_t count;
|
|
|
|
off_t i;
|
|
|
|
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
|
|
|
|
_eio_file_copy_heavy(Ecore_Thread *thread, void *data)
|
|
|
|
{
|
|
|
|
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-10-05 09:57:51 -07:00
|
|
|
_eio_file_copy_notify(Ecore_Thread *thread __UNUSED__, void *msg_data, void *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
|
|
|
|
_eio_file_copy_end(void *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_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
|
|
|
|
|
|
|
copy->common.done_cb((void*) copy->common.data);
|
|
|
|
|
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
|
|
|
|
_eio_file_copy_error(void *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_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
|
|
|
|
_eio_file_move_copy_progress(void *data, const Eio_Progress *info)
|
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
|
|
|
move->progress.progress_cb((void*) move->progress.common.data, info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_file_move_unlink_done(void *data)
|
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
|
|
|
move->progress.common.done_cb((void*) move->progress.common.data);
|
|
|
|
|
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
|
|
|
|
_eio_file_move_unlink_error(int error, void *data)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
_eio_file_move_copy_done(void *data)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
_eio_file_move_copy_error(int error, void *data)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
_eio_file_move_heavy(Ecore_Thread *thread, void *data)
|
|
|
|
{
|
|
|
|
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-10-05 09:57:51 -07:00
|
|
|
_eio_file_move_notify(Ecore_Thread *thread __UNUSED__, void *msg_data, void *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
|
|
|
|
_eio_file_move_end(void *data)
|
|
|
|
{
|
|
|
|
Eio_File_Move *move = data;
|
|
|
|
|
|
|
|
move->progress.common.done_cb((void*) move->progress.common.data);
|
|
|
|
|
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
|
|
|
|
_eio_file_move_error(void *data)
|
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
op->progress_cb((void *) op->common.data, progress);
|
|
|
|
|
|
|
|
eio_progress_free(progress);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
eio_file_copy_do(Ecore_Thread *thread, Eio_File_Progress *copy)
|
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
int result = -1;
|
|
|
|
int in = -1;
|
|
|
|
int out = -1;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* open write */
|
|
|
|
out = open(copy->dest, O_WRONLY | O_CREAT | O_TRUNC, buf.st_mode);
|
|
|
|
if (out < 0)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
#ifdef EFL_HAVE_SPLICE
|
|
|
|
/* 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 */
|
|
|
|
if (result == -1 && !_eio_file_copy_mmap(thread, copy, in, out, buf.st_size))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* change access right to match source */
|
|
|
|
if (fchmod(out, buf.st_mode) != 0)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
close(out);
|
|
|
|
close(in);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
on_error:
|
|
|
|
eio_file_thread_error(©->common, thread);
|
|
|
|
|
|
|
|
if (in >= 0) close(in);
|
|
|
|
if (out >= 0) close(out);
|
|
|
|
if (out >= 0)
|
|
|
|
unlink(copy->dest);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*============================================================================*
|
|
|
|
* API *
|
|
|
|
*============================================================================*/
|
2010-10-12 07:59:30 -07:00
|
|
|
|
|
|
|
/**
|
2010-10-20 22:03:23 -07:00
|
|
|
* @addtogroup Eio_Group Eio Reference API
|
2010-10-12 07:59:30 -07:00
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
2010-07-23 04:00:44 -07:00
|
|
|
/**
|
|
|
|
* @brief List content of a directory without locking your app.
|
|
|
|
* @param dir The directory to list.
|
|
|
|
* @param filter_cb Callback called from another thread.
|
|
|
|
* @param main_cb Callback called from the main loop for each accepted file.
|
|
|
|
* @param done_cb Callback called from the main loop when the content of the directory has been listed.
|
|
|
|
* @param error_cb Callback called from the main loop when the directory could not be opened or listing content has been canceled.
|
2010-10-20 05:08:56 -07:00
|
|
|
* @param data Data passed to callback and not modified at all by eio_file_ls.
|
2010-07-23 04:00:44 -07:00
|
|
|
* @return A reference to the IO operation.
|
|
|
|
*
|
2010-09-22 02:47:55 -07:00
|
|
|
* eio_file_ls run eina_file_ls in a separated thread using ecore_thread_feedback_run. This prevent
|
2010-07-23 04:00:44 -07:00
|
|
|
* any lock in your apps.
|
|
|
|
*/
|
|
|
|
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,
|
|
|
|
_eio_file_end,
|
|
|
|
_eio_file_error))
|
|
|
|
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
|
|
|
/**
|
|
|
|
* @brief List content of a directory without locking your app.
|
|
|
|
* @param dir The directory to list.
|
|
|
|
* @param filter_cb Callback called from another thread.
|
|
|
|
* @param main_cb Callback called from the main loop for each accepted file.
|
|
|
|
* @param done_cb Callback called from the main loop when the content of the directory has been listed.
|
|
|
|
* @param error_cb Callback called from the main loop when the directory could not be opened or listing content has been canceled.
|
2010-10-20 05:08:56 -07:00
|
|
|
* @param data Data passed to callback and not modified at all by eio_file_direct_ls.
|
2010-07-23 04:00:44 -07:00
|
|
|
* @return A reference to the IO operation.
|
|
|
|
*
|
|
|
|
* eio_file_direct_ls run eina_file_direct_ls in a separated thread using
|
2010-09-22 02:47:55 -07:00
|
|
|
* ecore_thread_feedback_run. This prevent any lock in your apps.
|
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,
|
|
|
|
_eio_file_end,
|
|
|
|
_eio_file_error))
|
|
|
|
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
|
|
|
}
|
|
|
|
|
* 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
|
|
|
/**
|
|
|
|
* @brief Cancel any Eio_File.
|
|
|
|
* @param ls The asynchronous IO operation to cancel.
|
|
|
|
* @return EINA_FALSE if the destruction is delayed, EINA_TRUE if it's done.
|
|
|
|
*
|
|
|
|
* This will cancel any kind of IO operation and cleanup the mess. This means
|
|
|
|
* that it could take time to cancel an IO.
|
|
|
|
*/
|
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
|
|
|
}
|
|
|
|
|
* 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
|
|
|
/**
|
|
|
|
* @brief Copy a file asynchronously
|
|
|
|
* @param source Should be the name of the file to copy the data from.
|
|
|
|
* @param dest Should be the name of the file to copy the data to.
|
|
|
|
* @param progress_cb Callback called to know the progress of the copy.
|
|
|
|
* @param done_cb Callback called when the copy is done.
|
|
|
|
* @param error_cb Callback called when something goes wrong.
|
|
|
|
* @param data Private data given to callback.
|
|
|
|
*
|
|
|
|
* This function will copy a file from source to dest. It will try to use splice
|
2010-10-05 07:29:58 -07:00
|
|
|
* if possible, if not it will fallback to mmap/write. It will try to preserve
|
|
|
|
* access right, but not user/group identification.
|
* 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;
|
|
|
|
}
|
|
|
|
|
2010-10-05 07:29:58 -07:00
|
|
|
/**
|
|
|
|
* @brief Move a file asynchronously
|
|
|
|
* @param source Should be the name of the file to move the data from.
|
|
|
|
* @param dest Should be the name of the file to move the data to.
|
|
|
|
* @param progress_cb Callback called to know the progress of the move.
|
|
|
|
* @param done_cb Callback called when the move is done.
|
|
|
|
* @param error_cb Callback called when something goes wrong.
|
|
|
|
* @param data Private data given to callback.
|
|
|
|
*
|
|
|
|
* This function will copy a file from source to dest. It will try to use splice
|
|
|
|
* if possible, if not it will fallback to mmap/write. It will try to preserve
|
|
|
|
* access right, but not user/group identification.
|
|
|
|
|
|
|
|
*/
|
* 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;
|
|
|
|
}
|
2010-10-12 07:59:30 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|