static int cephwrap_closedir(struct vfs_handle_struct *handle, DIR *dirp)
{
int result;
DBG_DEBUG("[CEPH] closedir(%p, %p)\n", handle, dirp);
result = ceph_closedir(handle->data, (struct ceph_dir_result *) dirp);
DBG_DEBUG("[CEPH] closedir(...) = %d\n", result);
WRAP_RETURN(result);
}
void cfs_walk_dir_generic(struct ceph_mount_info* _fs, const char* _entry_point, cfs_dentry_handler_t _handler, cfs_dentry_comparator_t _comparator, void* _data, unsigned int _level)
{
int ceph_opendir_res = -1;
int ceph_readdirplus_r_res = 0;
int sb_mask = 0;
char path[PATH_MAX];
struct ceph_dir_result* cfs_dir = NULL;
struct dirent entry;
struct stat sb;
pfcq_zero(&entry, sizeof(struct dirent));
pfcq_zero(&sb, sizeof(struct stat));
pfcq_zero(path, PATH_MAX);
debug("Walking into %s entry...\n", _entry_point);
ceph_opendir_res = ceph_opendir(_fs, _entry_point, &cfs_dir);
if (unlikely(ceph_opendir_res != 0))
{
warning("ceph_opendir");
goto out;
}
while (likely((ceph_readdirplus_r_res = ceph_readdirplus_r(_fs, cfs_dir, &entry, &sb, &sb_mask)) == 1))
{
if (unlikely(strcmp(entry.d_name, ".") == 0 || strcmp(entry.d_name, "..") == 0))
continue;
if (likely(_comparator))
if (unlikely(!_comparator(_entry_point, &entry, &sb, _level)))
continue;
if (likely(strcmp(_entry_point, "/") == 0))
{
if (unlikely(snprintf(path, PATH_MAX, "/%s", entry.d_name) < 0))
continue;
} else
{
if (unlikely(snprintf(path, PATH_MAX, "%s/%s", _entry_point, entry.d_name) < 0))
continue;
}
if (likely(_handler))
_handler(_fs, path, &entry, &sb, _data, _level);
}
if (unlikely(ceph_closedir(_fs, cfs_dir) != 0))
warning("ceph_closedir");
out:
debug("Walking out of %s entry...\n", _entry_point);
return;
}
int cfs_mkdir_safe(struct ceph_mount_info* _fs, const char* _path, mode_t _mode)
{
int ret = 0;
int ceph_opendir_res = -1;
struct ceph_dir_result* cfs_dir = NULL;
if (unlikely(pthread_mutex_lock(&cfs_mkdir_safe_lock)))
panic("pthread_mutex_lock");
ceph_opendir_res = ceph_opendir(_fs, _path, &cfs_dir);
if (unlikely(ceph_opendir_res != 0))
ret = ceph_mkdir(_fs, _path, _mode);
else
ceph_closedir(_fs, cfs_dir);
if (unlikely(pthread_mutex_unlock(&cfs_mkdir_safe_lock)))
panic("pthread_mutex_unlock");
return ret;
}
/*
* Get the next file to backup.
*/
static bRC get_next_file_to_backup(bpContext *ctx)
{
int status;
struct save_pkt sp;
struct dirent *entry;
plugin_ctx *p_ctx = (plugin_ctx *)ctx->pContext;
/*
* See if we just saved the directory then we are done processing this directory.
*/
switch (p_ctx->type) {
case FT_DIREND:
/*
* See if there is anything on the dir stack to pop off and continue reading that directory.
*/
if (!p_ctx->dir_stack->empty()) {
const char *cwd;
struct dir_stack_entry *new_entry;
/*
* Change the GLFS cwd back one dir.
*/
status = ceph_chdir(p_ctx->cmount, "..");
if (status < 0) {
berrno be;
Jmsg(ctx, M_ERROR, "ceph_chdir(%s) failed: %s\n", "..", be.bstrerror(-status));
return bRC_Error;
}
/*
* Save where we are in the tree.
*/
cwd = ceph_getcwd(p_ctx->cmount);
pm_strcpy(p_ctx->cwd, cwd);
/*
* Pop the previous directory handle and continue processing that.
*/
new_entry = (struct dir_stack_entry *)p_ctx->dir_stack->pop();
memcpy(&p_ctx->statp, &new_entry->statp, sizeof(p_ctx->statp));
p_ctx->cdir = new_entry->cdir;
free(new_entry);
} else {
return bRC_OK;
}
break;
default:
break;
}
if (!p_ctx->cdir) {
return bRC_Error;
}
/*
* Loop until we know what file is next or when we are done.
*/
while (1) {
int stmask = 0;
memset(&p_ctx->statp, 0, sizeof(p_ctx->statp));
memset(&p_ctx->de, 0, sizeof(p_ctx->de));
status = ceph_readdirplus_r(p_ctx->cmount, p_ctx->cdir, &p_ctx->de, &p_ctx->statp, &stmask);
/*
* No more entries in this directory ?
*/
if (status == 0) {
status = ceph_stat(p_ctx->cmount, p_ctx->cwd, &p_ctx->statp);
if (status < 0) {
berrno be;
Jmsg(ctx, M_ERROR, "ceph_stat(%s) failed: %s\n", p_ctx->cwd, be.bstrerror(-status));
return bRC_Error;
}
status = ceph_closedir(p_ctx->cmount, p_ctx->cdir);
if (status < 0) {
berrno be;
Jmsg(ctx, M_ERROR, "ceph_closedir(%s) failed: %s\n", p_ctx->cwd, be.bstrerror(-status));
return bRC_Error;
}
p_ctx->cdir = NULL;
p_ctx->type = FT_DIREND;
pm_strcpy(p_ctx->next_filename, p_ctx->cwd);
Dmsg(ctx, dbglvl, "cephfs-fd: next file to backup %s\n", p_ctx->next_filename);
return bRC_More;
}
entry = &p_ctx->de;
/*
* Skip `.', `..', and excluded file names.
*/
if (entry->d_name[0] == '\0' ||
(entry->d_name[0] == '.' && (entry->d_name[1] == '\0' ||
(entry->d_name[1] == '.' && entry->d_name[2] == '\0')))) {
continue;
}
Mmsg(p_ctx->next_filename, "%s/%s", p_ctx->cwd, entry->d_name);
/*
* Determine the FileType.
*/
switch (p_ctx->statp.st_mode & S_IFMT) {
case S_IFREG:
p_ctx->type = FT_REG;
break;
case S_IFLNK:
p_ctx->type = FT_LNK;
status = ceph_readlink(p_ctx->cmount, p_ctx->next_filename,
p_ctx->link_target, sizeof_pool_memory(p_ctx->link_target));
if (status < 0) {
berrno be;
Jmsg(ctx, M_ERROR, "ceph_readlink(%s) failed: %s\n", p_ctx->next_filename, be.bstrerror(-status));
p_ctx->type = FT_NOFOLLOW;
}
p_ctx->link_target[status] = '\0';
break;
case S_IFDIR:
p_ctx->type = FT_DIRBEGIN;
break;
case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
#ifdef S_IFSOCK
case S_IFSOCK:
#endif
p_ctx->type = FT_SPEC;
break;
default:
Jmsg(ctx, M_FATAL, "Unknown filetype encountered %ld for %s\n",
p_ctx->statp.st_mode & S_IFMT, p_ctx->next_filename);
return bRC_Error;
}
/*
* See if we accept this file under the currently loaded fileset.
*/
memset(&sp, 0, sizeof(sp));
sp.pkt_size = sizeof(sp);
sp.pkt_end = sizeof(sp);
sp.fname = p_ctx->next_filename;
sp.type = p_ctx->type;
memcpy(&sp.statp, &p_ctx->statp, sizeof(sp.statp));
if (bfuncs->AcceptFile(ctx, &sp) == bRC_Skip) {
Dmsg(ctx, dbglvl, "cephfs-fd: file %s skipped due to current fileset settings\n", p_ctx->next_filename);
continue;
}
/*
* If we made it here we have the next file to backup.
*/
break;
}
Dmsg(ctx, dbglvl, "cephfs-fd: next file to backup %s\n", p_ctx->next_filename);
return bRC_More;
}