static int storage_clear(const bt_addr_le_t *addr)
{
char path[STORAGE_PATH_MAX];
int err;
if (addr) {
#if MAX_FILE_NAME >= STORAGE_FILE_NAME_LEN
snprintk(path, STORAGE_PATH_MAX,
STORAGE_ROOT "/%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%u",
addr->a.val[5], addr->a.val[4], addr->a.val[3],
addr->a.val[2], addr->a.val[1], addr->a.val[0],
addr->type);
return unlink_recursive(path);
#else
return -ENAMETOOLONG;
#endif
}
/* unlink_recursive() uses the given path as a buffer for
* constructing sub-paths, so we can't give it a string literal
* such as STORAGE_ROOT directly.
*/
strcpy(path, STORAGE_ROOT);
err = unlink_recursive(path);
if (err) {
return err;
}
return fs_mkdir(STORAGE_ROOT);
}
static INT64_T chirp_fs_local_rmall(const char *path)
{
PREAMBLE("rmall(`%s')", path);
RESOLVE(path)
rc = unlink_recursive(path);
PROLOGUE
}
static int do_rm(int argc, char *argv[])
{
int i, opt, recursive = 0;
while ((opt = getopt(argc, argv, "r")) > 0) {
switch (opt) {
case 'r':
recursive = 1;
break;
default:
return COMMAND_ERROR_USAGE;
}
}
if (argc < 2)
return COMMAND_ERROR_USAGE;
i = optind;
while (i < argc) {
int ret;
if (recursive)
ret = unlink_recursive(argv[i], NULL);
else
ret = unlink(argv[i]);
if (ret) {
printf("could not remove %s: %s\n", argv[i], errno_str());
return 1;
}
i++;
}
return 0;
}
jboolean native_remove(JNIEnv* env, jclass clazz, jstring name) {
if (!name)
return JNI_FALSE;
const char *path = (*env)->GetStringUTFChars(env, name, NULL);
LOGI("native_remove %s", path);
return unlink_recursive(path) >= 0;
}
int uninstall_grub2(lickdir_t *lick) {
char drive = mount_uefi_partition();
if(drive == '\0') {
if(!lick->err)
lick->err = strdup2("Could not mount EFI partition.");
return 0;
}
if(!fix_grub2_inner(lick, GRUB2_FIX_UNINSTALL, drive)) {
unmount_uefi_partition(drive);
if(!lick->err)
lick->err = strdup2("Could not revert boot fix.");
return 0;
}
char *grub_cfg = unix_path(concat_strs(2, lick->drive, "/lickgrub.cfg"));
if(!has_valuable_info(grub_cfg)) {
unlink_file(grub_cfg);
}
free(grub_cfg);
char *lick_cert = strdup2("?:/lick.cer");
lick_cert[0] = drive;
unlink_file(lick_cert);
free(lick_cert);
char lick_dir[] = "?:/EFI/LICK";
lick_dir[0] = drive;
unlink_recursive(lick_dir);
unmount_uefi_partition(drive);
return 1;
}
static int sandbox_delete (const char *sandbox)
{
int rc;
CATCHUNIX(unlink_recursive(sandbox));
rc = 0;
goto out;
out:
return rc;
}
bool unlink_recursive(const char *path, bool include_self)
{
if (!path) {
return false;
}
DIR *dir;
struct dirent *e;
dir = opendir(path);
if (!dir) {
return false;
}
char *item = NULL;
while ((e = readdir(dir)) != NULL) {
if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, "..")) {
continue;
}
item = string_concat(path, "/", e->d_name, NULL);
if (!item) {
goto fail;
}
if (e->d_type == DT_REG) {
if (unlink(item) != 0) {
goto fail;
}
} else if (e->d_type == DT_DIR) {
if (unlink_recursive(item, true) != 0) {
goto fail;
}
}
free(item);
item = NULL;
}
closedir(dir);
if (include_self && rmdir(path) != 0) {
return false;
}
return true;
fail:
if (item) {
free(item);
}
closedir(dir);
return false;
}
static int unlink_recursive(char path[STORAGE_PATH_MAX])
{
size_t path_len;
fs_dir_t dir;
int err;
err = fs_opendir(&dir, path);
if (err) {
return err;
}
/* We calculate this up-front so we can keep reusing the same
* buffer for the path when recursing.
*/
path_len = strlen(path);
while (1) {
struct fs_dirent entry;
err = fs_readdir(&dir, &entry);
if (err) {
break;
}
if (entry.name[0] == '\0') {
break;
}
snprintk(path + path_len, STORAGE_PATH_MAX - path_len, "/%s",
entry.name);
if (entry.type == FS_DIR_ENTRY_DIR) {
err = unlink_recursive(path);
} else {
err = fs_unlink(path);
}
if (err) {
break;
}
}
fs_closedir(&dir);
/* Return to the original value */
path[path_len] = '\0';
fs_unlink(path);
return err;
}
/* return -1 on failure, with errno set to the first error */
static int unlink_recursive(const char* name, int flags)
{
struct stat st;
DIR *dir;
struct dirent *de;
int fail = 0;
/* is it a file or directory? */
if (stat(name, &st) < 0)
return ((flags & OPT_FORCE) && errno == ENOENT) ? 0 : -1;
/* a file, so unlink it */
if (!S_ISDIR(st.st_mode))
return unlink(name);
/* a directory, so open handle */
dir = opendir(name);
if (dir == NULL)
return -1;
/* recurse over components */
errno = 0;
while((de = readdir(dir)) != NULL) {
char dn[PATH_MAX];
if(strcmp(de->d_name, "..") == 0 || strcmp(de->d_name, ".") == 0) {
continue;
}
sprintf(dn, "%s/%s", name, de->d_name);
if(unlink_recursive(dn, flags) < 0) {
fail = 1;
break;
}
errno = 0;
}
/* in case readdir or unlink_recursive failed */
if (fail || errno) {
int save = errno;
closedir(dir);
errno = save;
return -1;
}
/* close directory handle */
if (closedir(dir) < 0)
return -1;
/* delete target directory */
return rmdir(name);
}
int rm_main(int argc, char *argv[])
{
int ret;
int i, c;
int flags = 0;
if(argc < 2) return usage();
/* check flags */
while(1) {
c = getopt(argc, argv, "frR");
if(c == EOF) break;
switch (c) {
case 'f':
flags |= OPT_FORCE;
break;
case 'r':
case 'R':
flags |= OPT_RECURSIVE;
break;
}
}
if(optind < 1 || optind >= argc) {
usage();
return -1;
}
/* loop over the file/directory args */
for(i = optind; i < argc; i++) {
if(flags & OPT_RECURSIVE) {
ret = unlink_recursive(argv[i], flags);
} else {
ret = unlink(argv[i]);
}
if(ret < 0 && (errno != ENOENT || !(flags & OPT_FORCE))) {
fprintf(stderr, "rm failed for %s, %s\n", argv[i], strerror(errno));
return -1;
}
}
return 0;
}
/* Remove partial or corrupted archive.
@return 1 if archive was successful, 0 if archive failed.
*/
static int makeflow_archive_remove_task(struct archive_instance *a, struct dag_node *n, struct batch_task *t) {
/* Generate the task id */
char *id = batch_task_generate_id(t);
/* The archive name is binned by the first 2 characters of the id for compactness */
char *archive_directory_path = string_format("%s/tasks/%.2s/%s", a->dir, id, id);
debug(D_MAKEFLOW_HOOK, "removing corrupt archive for task %d at %s", t->taskid, archive_directory_path);
free(id);
if(!unlink_recursive(archive_directory_path)){
debug(D_MAKEFLOW_HOOK, "unable to remove corrupt archive for task %d", t->taskid);
free(archive_directory_path);
return 0;
}
debug(D_MAKEFLOW_HOOK, "corrupt archive for task %d removed", t->taskid);
free(archive_directory_path);
return 1;
}
bench_t* bm_init(void *param){
bench_t* bp = (bench_t*)param;
bench_t* bp_new;
if(bp->mode == 0x0)
bp->mode = BM_MODE_COUNTER;
bp->processes = bp->num / BM_GROUP_THREADS;
bp->groupthreads = BM_GROUP_THREADS;
if(bp->num % BM_GROUP_THREADS > 0)
bp->processes += 1;
/*
* 通过pmalloc调用mmap
* 分配bench_child_t的空间
* bench_child_t的数量取决于子进程数
*/
pmalloc(sizeof(bench_t) + sizeof(bench_child_t)*(bp->processes),(void **)&mbp);
memset(mbp,0,sizeof(bench_t) + sizeof(bench_child_t)*(bp->processes));
memcpy(&mbp->bp,bp,sizeof(bench_t));
INIT_LIST_HEAD(&mbp->bp.children);
/*
* 如果日志输出目录已经存在
* 就删除掉
*/
int ret = 0;
if(bp->outfile){
// ret = rmdir(bp->outfile);
ret = unlink_recursive(bp->outfile);
if(ret != 0){
syslog(LOG_ERR,"rmdir %s faild - %m",bp->outfile);
}
}
mbp->bp.pid = getpid();///<获得主进程pid
return &mbp->bp;
}
static void unlink_recursive (const char *dirpath)
{
DIR *dir;
struct dirent *dirent;
char path[PATH_MAX + 1];
struct stat sb;
if ((dir = opendir (dirpath))) {
while ((dirent = readdir (dir))) {
if (!strcmp (dirent->d_name, ".") || !strcmp (dirent->d_name, ".."))
continue;
snprintf (path, sizeof (path), "%s/%s", dirpath, dirent->d_name);
if (lstat (path, &sb) < 0)
continue;
if (S_ISDIR (sb.st_mode))
unlink_recursive (path);
else
unlink (path);
}
closedir (dir);
rmdir (dirpath);
}
}
int makeflow_clean_mount_target(const char *target) {
file_type t_type;
if(!target || !*target) return 0;
/* Check whether target already exists. */
if(access(target, F_OK)) {
debug(D_DEBUG, "the target (%s) does not exist!\n", target);
return 0;
}
/* Check whether the target is an absolute path. */
if(target[0] == '/') {
debug(D_DEBUG, "the target (%s) should not be an absolute path!\n", target);
fprintf(stderr, "the target (%s) should not be an absolute path!\n", target);
return -1;
}
/* check whether target includes .. */
if(path_has_doubledots(target)) {
debug(D_DEBUG, "the target (%s) include ..!\n", target);
fprintf(stderr, "the target (%s) include ..!\n", target);
return -1;
}
/* check whether target is REG, LNK, DIR */
if((t_type = check_file_type(target)) == FILE_TYPE_UNSUPPORTED)
return -1;
if(unlink_recursive(target)) {
debug(D_DEBUG, "Failed to remove %s!\n", target);
fprintf(stderr, "Failed to remove %s!\n", target);
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
int ret;
int i;
int flags = 0;
if(argc < 2) {
usage();
return -1;
}
/* check flags */
while(1) {
int c = getopt(argc, argv, "frR");
if(c == -1) break;
switch (c) {
case 'f':
flags |= OPT_FORCE;
break;
case 'r':
case 'R':
flags |= OPT_RECURSIVE;
break;
}
}
if(optind < 1 || optind >= argc) {
usage();
return -1;
}
/* loop over the file/directory args */
for (i = optind; i < argc; i++) {
if (flags & OPT_RECURSIVE) {
ret = unlink_recursive(argv[i], flags);
} else {
//#ifdef _WIN32
if(access(argv[i], F_OK) == 0 && access(argv[i], W_OK) != 0) {
//if(flags & OPT_FORCE) chmod(argv[i], 666);
if(!(flags & OPT_FORCE)) {
//int a;
printf("remove write-protected file \"%s\"? ", argv[i]);
/*
a = getchar();
if(a == 'Y' || a == 'y') chmod(argv[i], 666);
else if(a == 'N' || a == 'n') return 1;
else {
fprintf(stderr, "Illegal input\n");
return 1;
}
*/
switch(getchar()) {
default:
fprintf(stderr, "Illegal input\n");
case 'N':
case 'n':
return 1;
case 'Y':
case 'y':
#if defined _WIN32 && !defined _WIN32_WNT_NATIVE
chmod(argv[i], 666);
#endif
break;
}
}
#if defined _WIN32 && !defined _WIN32_WNT_NATIVE
else chmod(argv[i], 666);
#endif
}
//#endif
ret = unlink(argv[i]);
/*
if (errno == ENOENT && !(flags & OPT_FORCE)) {
return 0;
}
*/
}
if(ret < 0 && (errno != ENOENT || !(flags & OPT_FORCE))) {
//#ifdef _WIN32_WCE
// fprintf(stderr, "rm failed for %s\n", argv[i]);
//#else
fprintf(stderr, "rm failed for %s, %s\n", argv[i], strerror(errno));
//#endif
//if(errno != ENOENT || !(flags & OPT_FORCE)) return -1;
return -1;
}
}
return 0;
}
void *linux_bootchart_thread (void *ignored) {
struct cfgnode *node;
char *save_to = "/var/log/bootchart.tgz";
FILE *f;
char try_acct = 1;
signed int extra_wait = 0;
if ((node = cfg_getnode ("configuration-bootchart-extra-waiting-time", NULL)) && node->value) {
extra_wait = node->value;
}
char *buffer_ds = NULL;
char *buffer_ps = NULL;
char *buffer_st = NULL;
while (!shutting_down && (linux_bootchart_have_thread || (extra_wait > 0))) {
char *uptime = linux_bootchart_get_uptime();
if (linux_bootchart_process_accounting && try_acct) {
if (acct ("/dev/kernel_pacct") == -1)
try_acct = 1;
}
if (uptime) {
buffer_ds = linux_bootchart_update_ds (buffer_ds, uptime);
buffer_ps = linux_bootchart_update_ps (buffer_ps, uptime);
buffer_st = linux_bootchart_update_st (buffer_st, uptime);
free (uptime);
uptime = NULL;
}
usleep (linux_bootchart_sleep_time);
if (!linux_bootchart_have_thread)
extra_wait -= linux_bootchart_sleep_time;
}
if ((node = cfg_getnode ("configuration-bootchart-save-to", NULL)) && node->svalue) {
save_to = node->svalue;
}
if (coremode & einit_mode_sandbox) {
save_to = "bootchart.tgz";
}
mkdir ("/tmp/bootchart.einit", 0755);
if (buffer_ds) {
if ((f = fopen ("/tmp/bootchart.einit/proc_diskstats.log", "w"))) {
fputs (buffer_ds, f);
fclose (f);
}
free (buffer_ds);
buffer_ds = NULL;
}
if (buffer_ps) {
if ((f = fopen ("/tmp/bootchart.einit/proc_ps.log", "w"))) {
fputs (buffer_ps, f);
fclose (f);
}
free (buffer_ps);
buffer_ps = NULL;
}
if (buffer_st) {
if ((f = fopen ("/tmp/bootchart.einit/proc_stat.log", "w"))) {
fputs (buffer_st, f);
fclose (f);
}
free (buffer_st);
buffer_st = NULL;
}
if (linux_bootchart_process_accounting) {
char *r = readfile ("/dev/kernel_pacct");
if (r) {
if ((f = fopen ("/tmp/bootchart.einit/kernel_pacct", "w"))) {
fputs (r, f);
fclose (f);
}
unlink ("/dev/kernel_pacct");
}
acct(NULL);
}
if ((f = fopen ("/tmp/bootchart.einit/header", "w"))) {
char *t, buffer[BUFFERSIZE];
time_t ti = time(NULL);
/* we're emulating bootchartd-0.8/0.9's format... */
eputs ("version = 0.8\n", f);
if (gethostname (buffer, BUFFERSIZE) == 0) {
eprintf (f, "title = eINIT Boot Chart for %s, %s", buffer, ctime(&ti));
} else {
eprintf (f, "title = eINIT Boot Chart, %s", ctime(&ti));
}
fprintf (f, "system.uname = %s %s %s %s\n", osinfo.sysname, osinfo.release, osinfo.version, osinfo.machine);
if ((t = readfile ("/etc/gentoo-release"))) {
strtrim (t);
eprintf (f, "system.release = %s\n", t);
free (t);
} else {
eputs ("system.release = unknown\n", f);
}
if ((t = readfile ("/proc/cpuinfo"))) {
char **r = str2set ('\n', t);
char *n = NULL;
int i;
if (r) {
for (i = 0; r[i]; i++) {
if (strstr (r[i], "model name") == r[i]) {
n = r[i];
break;
}
}
if (n)
eprintf (f, "system.cpu = %s\n", n);
else
eputs ("system.cpu = unknown\n", f);
}
free (t);
} else {
eputs ("system.cpu = unknown\n", f);
}
if ((t = readfile ("/proc/cmdline"))) {
eprintf (f, "system.kernel.options = %s\n", t);
free (t);
}
fclose (f);
}
char buffer[BUFFERSIZE];
if (coremode & einit_mode_sandbox) {
esprintf (buffer, BUFFERSIZE, "export pwx=`pwd`; cd /tmp/bootchart.einit; tar czf \"${pwx}/%s\" *", save_to);
} else {
esprintf (buffer, BUFFERSIZE, "cd /tmp/bootchart.einit; tar czf %s *", save_to);
}
system (buffer);
unlink_recursive ("/tmp/bootchart.einit/", 1);
char *di = cfg_getstring ("configuration-bootchart-chart-directory", NULL);
char *fo = cfg_getstring ("configuration-bootchart-chart-format", NULL);
esprintf (buffer, BUFFERSIZE, "bootchart -o %s -f %s %s", di, fo, save_to);
return NULL;
}
static int do_loadenv(int argc, char *argv[])
{
char *filename = NULL, *dirname;
unsigned flags = 0;
int opt;
int scrub = 0;
int defaultenv = 0;
while ((opt = getopt(argc, argv, "nsd")) > 0) {
switch (opt) {
case 'n':
flags |= ENV_FLAG_NO_OVERWRITE;
break;
case 's':
scrub = 1;
break;
case 'd':
defaultenv = 1;
break;
default:
return COMMAND_ERROR_USAGE;
}
}
if (argc - optind < 2)
dirname = "/env";
else
dirname = argv[optind + 1];
if (argc - optind < 1) {
filename = default_environment_path_get();
} else {
char *str = normalise_path(argv[optind]);
/*
* /dev/defaultenv use to contain the defaultenvironment.
* we do not have this file anymore, but maintain compatibility
* to the 'loadenv -s /dev/defaultenv' command to restore the
* default environment for some time.
*/
if (!strcmp(str, "/dev/defaultenv"))
defaultenv = 1;
else
filename = argv[optind];
free(str);
}
if (scrub) {
int ret;
ret = unlink_recursive(dirname, NULL);
if (ret && ret != -ENOENT) {
eprintf("cannot remove %s: %s\n", dirname,
strerror(-ret));
return 1;
}
ret = mkdir(dirname, 0);
if (ret) {
eprintf("cannot create %s: %s\n", dirname,
strerror(-ret));
return ret;
}
}
printf("loading environment from %s\n", defaultenv ? "defaultenv" : filename);
if (defaultenv)
return defaultenv_load(dirname, flags);
else
return envfs_load(filename, dirname, flags);
}
int makeflow_clean(struct dag *d, struct batch_queue *queue, makeflow_clean_depth clean_depth)//, struct makeflow_wrapper *w, struct makeflow_monitor *m)
{
struct dag_file *f;
char *name;
hash_table_firstkey(d->files);
while(hash_table_nextkey(d->files, &name, (void **) &f)) {
int silent = 1;
if(dag_file_should_exist(f))
silent = 0;
/* We have a record of the file, but it is no longer created or used so delete */
if(dag_file_is_source(f) && dag_file_is_sink(f) && !set_lookup(d->inputs, f))
makeflow_clean_file(d, queue, f, silent);
if(dag_file_is_source(f)) {
if(f->source && (clean_depth == MAKEFLOW_CLEAN_CACHE || clean_depth == MAKEFLOW_CLEAN_ALL)) { /* this file is specified in the mountfile */
if(makeflow_clean_mount_target(f->filename)) {
fprintf(stderr, "Failed to remove %s!\n", f->filename);
return -1;
}
}
continue;
}
if(clean_depth == MAKEFLOW_CLEAN_ALL) {
makeflow_clean_file(d, queue, f, silent);
} else if(set_lookup(d->outputs, f) && (clean_depth == MAKEFLOW_CLEAN_OUTPUTS)) {
makeflow_clean_file(d, queue, f, silent);
} else if(!set_lookup(d->outputs, f) && (clean_depth == MAKEFLOW_CLEAN_INTERMEDIATES)){
makeflow_clean_file(d, queue, f, silent);
}
}
/* clean up the cache dir created due to the usage of mountfile */
if(clean_depth == MAKEFLOW_CLEAN_CACHE || clean_depth == MAKEFLOW_CLEAN_ALL) {
if(d->cache_dir && unlink_recursive(d->cache_dir)) {
fprintf(stderr, "Failed to clean up the cache dir (%s) created due to the usage of the mountfile!\n", d->cache_dir);
dag_mount_clean(d);
return -1;
}
dag_mount_clean(d);
}
struct dag_node *n;
for(n = d->nodes; n; n = n->next) {
/* If the node is a Makeflow job, then we should recursively call the *
* clean operation on it. */
if(n->nested_job) {
char *command = xxmalloc(sizeof(char) * (strlen(n->command) + 4));
sprintf(command, "%s -c", n->command);
/* XXX this should use the batch job interface for consistency */
makeflow_node_export_variables(d, n);
system(command);
free(command);
}
}
return 0;
}
/**
* Make the current environment persistent
* @param[in] filename where to store
* @param[in] dirname what to store (all files in this dir)
* @param[in] flags superblock flags (refer ENVFS_FLAGS_* macros)
* @return 0 on success, anything else in case of failure
*
* Note: This function will also be used on the host! See note in the header
* of this file.
*/
int envfs_save(const char *filename, const char *dirname, unsigned flags)
{
struct envfs_super *super;
int envfd, size, ret;
struct action_data data = {};
void *buf = NULL, *wbuf;
struct envfs_entry *env;
if (!filename)
filename = default_environment_path_get();
if (!dirname)
dirname = "/env";
data.writep = NULL;
data.base = dirname;
#ifdef __BAREBOX__
defaultenv_load(TMPDIR, 0);
#endif
if (flags & ENVFS_FLAGS_FORCE_BUILT_IN) {
size = 0; /* force no content */
} else {
/* first pass: calculate size */
recursive_action(dirname, ACTION_RECURSE, file_action,
NULL, &data, 0);
recursive_action("/.defaultenv", ACTION_RECURSE,
file_remove_action, NULL, &data, 0);
size = 0;
for (env = data.env; env; env = env->next) {
size += PAD4(env->size);
size += sizeof(struct envfs_inode);
size += PAD4(strlen(env->name) + 1);
size += sizeof(struct envfs_inode_end);
}
}
buf = xzalloc(size + sizeof(struct envfs_super));
data.writep = buf + sizeof(struct envfs_super);
super = buf;
super->magic = ENVFS_32(ENVFS_MAGIC);
super->major = ENVFS_MAJOR;
super->minor = ENVFS_MINOR;
super->size = ENVFS_32(size);
super->flags = ENVFS_32(flags);
if (!(flags & ENVFS_FLAGS_FORCE_BUILT_IN)) {
/* second pass: copy files to buffer */
env = data.env;
while (env) {
struct envfs_entry *next = env->next;
envfs_save_inode(&data, env);
free(env->buf);
free(env->name);
free(env);
env = next;
}
}
super->crc = ENVFS_32(crc32(0, buf + sizeof(struct envfs_super), size));
super->sb_crc = ENVFS_32(crc32(0, buf, sizeof(struct envfs_super) - 4));
envfd = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
if (envfd < 0) {
printf("could not open %s: %s\n", filename, errno_str());
ret = -errno;
goto out1;
}
ret = protect(envfd, ~0, 0, 0);
/* ENOSYS and EOPNOTSUPP aren't errors here, many devices don't need it */
if (ret && errno != ENOSYS && errno != EOPNOTSUPP) {
printf("could not unprotect %s: %s\n", filename, errno_str());
goto out;
}
ret = erase(envfd, ~0, 0);
/* ENOSYS and EOPNOTSUPP aren't errors here, many devices don't need it */
if (ret && errno != ENOSYS && errno != EOPNOTSUPP) {
printf("could not erase %s: %s\n", filename, errno_str());
goto out;
}
size += sizeof(struct envfs_super);
wbuf = buf;
while (size) {
ssize_t now = write(envfd, wbuf, size);
if (now < 0) {
ret = -errno;
goto out;
}
wbuf += now;
size -= now;
}
ret = protect(envfd, ~0, 0, 1);
/* ENOSYS and EOPNOTSUPP aren't errors here, many devices don't need it */
if (ret && errno != ENOSYS && errno != EOPNOTSUPP) {
printf("could not protect %s: %s\n", filename, errno_str());
goto out;
}
ret = 0;
out:
close(envfd);
out1:
free(buf);
#ifdef __BAREBOX__
unlink_recursive(TMPDIR, NULL);
#endif
return ret;
}
void cleanup_directory_recursive (const struct cleaner *c)
{
if (c && c->arg)
unlink_recursive (c->arg);
}
int main(int argc, char *argv[])
{
int port = WORK_QUEUE_DEFAULT_PORT;
const char *port_file=0;
const char *project_name=0;
int monitor_flag = 0;
int c;
while((c = getopt(argc, argv, "d:o:mN:p:Z:vh"))!=-1) {
switch (c) {
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'm':
monitor_flag = 1;
break;
case 'N':
project_name = optarg;
break;
case 'Z':
port_file = strdup(optarg);
port = 0;
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 0;
break;
case 'h':
show_help(path_basename(argv[0]));
return 0;
default:
show_help(path_basename(argv[0]));
return 1;
}
}
struct work_queue *q = work_queue_create(port);
if(!q) fatal("couldn't listen on any port!");
printf("listening on port %d...\n", work_queue_port(q));
if(port_file) {
FILE *file = fopen(port_file,"w");
if(!file) fatal("couldn't open %s: %s",port_file,strerror(errno));
fprintf(file,"%d\n",work_queue_port(q));
fclose(file);
}
if(project_name) {
work_queue_specify_name(q,project_name);
}
if(monitor_flag) {
unlink_recursive("work-queue-test-monitor");
work_queue_enable_monitoring(q, "work-queue-test-monitor");
work_queue_specify_category_mode(q, NULL, WORK_QUEUE_ALLOCATION_MODE_MAX_THROUGHPUT);
work_queue_specify_transactions_log(q, "work-queue-test-monitor/transactions.log");
}
int result = work_queue_mainloop(q);
work_queue_delete(q);
return result;
}
