static inline void undo_rm_helper( entry_id_t * id, const char *last_known_path,
#ifdef _HSM_LITE
const char *bkpath
#endif
)
{
entry_id_t new_id;
recov_status_t st;
attr_set_t attrs, new_attrs;
int rc;
/* XXX src path must be in the same filesystem as backend
* because it we be renamed */
if ( EMPTY_STRING( last_known_path ) )
{
fprintf(stderr, "Last filesystem path is not known for fid "DFID", backend_path=%s.\n",
PFID(id), bkpath);
fprintf(stderr, " ----> skipped\n");
return;
}
printf("Restoring '%s'...\n", last_known_path );
ATTR_MASK_INIT(&attrs);
ATTR_MASK_SET(&attrs, fullpath);
strcpy( ATTR(&attrs, fullpath), last_known_path );
if ( !EMPTY_STRING( bkpath ) )
{
ATTR_MASK_SET(&attrs, backendpath);
strcpy( ATTR(&attrs, backendpath), bkpath );
}
/* copy file to Lustre */
ATTR_MASK_INIT(&new_attrs);
st = rbhext_recover( id, &attrs, &new_id, &new_attrs, NULL );
if ((st == RS_FILE_OK) || (st == RS_FILE_DELTA)|| (st == RS_FILE_EMPTY)
|| (st == RS_NON_FILE))
{
printf("Success\n");
/* discard entry from remove list */
if ( ListMgr_SoftRemove_Discard(&lmgr, id) != 0 )
fprintf(stderr, "Error: could not remove previous id "DFID" from database\n", PFID(id) );
/* clean read-only attrs */
new_attrs.attr_mask &= ~readonly_attr_set;
/* insert or update it in the db */
rc = ListMgr_Insert( &lmgr, &new_id, &new_attrs, TRUE );
if ( rc == 0 )
printf("Entry successfully updated in the dabatase\n");
else
fprintf(stderr, "ERROR %d inserting entry in the database\n", rc );
}
else
{
printf("ERROR\n");
}
}
int EntryProc_db_flag_op( struct entry_proc_op_t *p_op, lmgr_t * lmgr )
{
int rc;
/* insert to DB */
switch ( p_op->db_op_type )
{
attr_set_t attr_chg;
lmgr_filter_t filter;
filter_value_t val;
case OP_TYPE_UPDATE:
/* set previous_scan flag */
ATTR_MASK_INIT( &attr_chg );
ATTR_MASK_SET( &attr_chg, previous_scan );
ATTR( &attr_chg, previous_scan ) = TRUE;
rc = ListMgr_MassUpdate( lmgr, NULL, &attr_chg );
break;
case OP_TYPE_REMOVE:
val.val_bool = TRUE;
lmgr_simple_filter_init( &filter );
lmgr_simple_filter_add( &filter, ATTR_INDEX_previous_scan, EQUAL, val );
/* remove entries with previous_scan flag */
rc = ListMgr_MassRemove( lmgr, &filter );
lmgr_simple_filter_free( &filter );
break;
default:
printf( "unhandled\n" );
rc = -1;
}
if ( rc )
printf( "ERROR: ListMgr mass operation returned %d\n", rc );
if ( p_op->callback_func )
p_op->callback_func( lmgr, p_op, p_op->callback_param );
rc = EntryProcessor_Acknowledge( p_op, 0, TRUE );
return rc;
}
int update_stripe_info(lmgr_t *p_mgr, PK_ARG_T pk, int validator,
const stripe_info_t *p_stripe,
const stripe_items_t *p_items, bool insert_if_absent)
{
attr_set_t fake_attr;
attr_set_t *p_attr = &fake_attr;
pktype list[1];
rh_strncpy(list[0], pk, sizeof(*list));
ATTR_MASK_INIT(&fake_attr);
if (p_stripe) {
ATTR_MASK_SET(&fake_attr, stripe_info);
ATTR(&fake_attr, stripe_info) = *p_stripe;
}
if (p_items) {
ATTR_MASK_SET(&fake_attr, stripe_items);
ATTR(&fake_attr, stripe_items) = *p_items;
}
return batch_insert_stripe_info(p_mgr, list, &validator, &p_attr, 1, true);
}
/**
* Bulk filtering in the DB.
*/
static int list_bulk(void)
{
attr_set_t root_attrs, attrs;
entry_id_t root_id, id;
int rc;
struct stat st;
struct lmgr_iterator_t *it;
/* no tranvsersal => no wagon
* so we need the path from the DB.
*/
query_mask |= ATTR_MASK_fullpath;
ATTR_MASK_INIT(&root_attrs);
rc = retrieve_root_id(&root_id);
if (rc)
return rc;
/* root is not a part of the DB: print it now */
ATTR_MASK_SET(&root_attrs, fullpath);
strcpy(ATTR(&root_attrs, fullpath), config.global_config.fs_path);
if (lstat(ATTR(&root_attrs, fullpath), &st) == 0)
{
PosixStat2EntryAttr(&st, &root_attrs, TRUE);
ListMgr_GenerateFields(&root_attrs, disp_mask | query_mask);
}
/* root has no name... */
ATTR_MASK_SET(&root_attrs, name);
ATTR(&root_attrs, name)[0] = '\0';
/* match condition on dirs parent */
if (!is_expr || (EntryMatches(&root_id, &root_attrs,
&match_expr, NULL) == POLICY_MATCH))
{
/* don't display dirs if no_dir is specified */
if (! (prog_options.no_dir && ATTR_MASK_TEST(&root_attrs, type)
&& !strcasecmp(ATTR(&root_attrs, type), STR_TYPE_DIR))) {
wagon_t w;
w.id = root_id;
w.fullname = ATTR(&root_attrs, fullpath);
print_entry(&w, &root_attrs);
}
}
/* list all, including dirs */
it = ListMgr_Iterator(&lmgr, &entry_filter, NULL, NULL);
if (!it)
{
DisplayLog(LVL_MAJOR, FIND_TAG, "ERROR: cannot retrieve entry list from database");
return -1;
}
attrs.attr_mask = disp_mask | query_mask;
while ((rc = ListMgr_GetNext(it, &id, &attrs)) == DB_SUCCESS)
{
if (!is_expr || (EntryMatches(&id, &attrs, &match_expr, NULL)
== POLICY_MATCH))
{
/* don't display dirs if no_dir is specified */
if (! (prog_options.no_dir && ATTR_MASK_TEST(&attrs, type)
&& !strcasecmp(ATTR(&attrs, type), STR_TYPE_DIR))) {
wagon_t w;
w.id = id;
w.fullname = ATTR(&attrs, fullpath);
print_entry(&w, &attrs);
}
/* don't display non dirs is dir_only is specified */
else if (! (prog_options.dir_only && ATTR_MASK_TEST(&attrs, type)
&& strcasecmp(ATTR(&attrs, type), STR_TYPE_DIR))) {
wagon_t w;
w.id = id;
w.fullname = ATTR(&attrs, fullpath);
print_entry(&w, &attrs);
}
else
/* return entry don't match? */
DisplayLog(LVL_DEBUG, FIND_TAG, "Warning: returned DB entry doesn't match filter: %s",
ATTR(&attrs, fullpath));
}
ListMgr_FreeAttrs(&attrs);
/* prepare next call */
attrs.attr_mask = disp_mask | query_mask;
}
ListMgr_CloseIterator(it);
return 0;
}
/**
* check if the entry exists in the database and what info
* must be retrieved.
*/
int EntryProc_get_info_db( struct entry_proc_op_t *p_op, lmgr_t * lmgr )
{
int rc = 0;
int next_stage = -1; /* -1 = skip */
attr_mask_t attr_allow_cached = null_mask;
attr_mask_t attr_need_fresh = null_mask;
uint32_t status_scope = 0; /* status mask only */
attr_mask_t tmp;
const pipeline_stage_t *stage_info =
&entry_proc_pipeline[p_op->pipeline_stage];
/* check if entry is in policies scope */
add_matching_scopes_mask(&p_op->entry_id, &p_op->fs_attrs, true,
&status_scope);
/* XXX also retrieve needed attributes to check the scope? */
/* get diff attributes from DB and FS (to allow comparison) */
p_op->db_attr_need = attr_mask_or(&p_op->db_attr_need, &diff_mask);
tmp = attr_mask_and_not(&diff_mask, &p_op->fs_attrs.attr_mask);
p_op->fs_attr_need = attr_mask_or(&p_op->fs_attr_need, &tmp);
if (entry_proc_conf.detect_fake_mtime)
attr_mask_set_index(&p_op->db_attr_need, ATTR_INDEX_creation_time);
attr_allow_cached = attrs_for_status_mask(status_scope, false);
attr_need_fresh = attrs_for_status_mask(status_scope, true);
/* XXX check if entry is in policy scope? */
/* what must be retrieved from DB: */
tmp = attr_mask_and_not(&attr_allow_cached, &p_op->fs_attrs.attr_mask);
p_op->db_attr_need = attr_mask_or(&p_op->db_attr_need, &tmp);
/* no dircount for non-dirs */
if (ATTR_MASK_TEST(&p_op->fs_attrs, type) &&
!strcmp(ATTR(&p_op->fs_attrs, type), STR_TYPE_DIR))
{
attr_mask_unset_index(&p_op->db_attr_need, ATTR_INDEX_dircount);
}
/* no readlink for non symlinks */
if (ATTR_MASK_TEST(&p_op->fs_attrs, type)) /* likely */
{
if (!strcmp(ATTR(&p_op->fs_attrs, type), STR_TYPE_LINK))
{
attr_mask_set_index(&p_op->db_attr_need, ATTR_INDEX_link); /* check if it is known */
/* no stripe for symlinks */
attr_mask_unset_index(&p_op->db_attr_need, ATTR_INDEX_stripe_info);
attr_mask_unset_index(&p_op->db_attr_need, ATTR_INDEX_stripe_items);
}
else
attr_mask_unset_index(&p_op->db_attr_need, ATTR_INDEX_link);
}
if (!attr_mask_is_null(p_op->db_attr_need))
{
p_op->db_attrs.attr_mask = p_op->db_attr_need;
rc = ListMgr_Get(lmgr, &p_op->entry_id, &p_op->db_attrs);
if (rc == DB_SUCCESS)
{
p_op->db_exists = 1;
}
else if (rc == DB_NOT_EXISTS )
{
p_op->db_exists = 0;
ATTR_MASK_INIT( &p_op->db_attrs );
}
else
{
/* ERROR */
DisplayLog(LVL_CRIT, ENTRYPROC_TAG,
"Error %d retrieving entry "DFID" from DB: %s.", rc,
PFID(&p_op->entry_id), lmgr_err2str(rc));
p_op->db_exists = 0;
ATTR_MASK_INIT( &p_op->db_attrs );
}
}
else
{
p_op->db_exists = ListMgr_Exists( lmgr, &p_op->entry_id );
}
/* get status for all policies with a matching scope */
add_matching_scopes_mask(&p_op->entry_id, &p_op->fs_attrs, true,
&p_op->fs_attr_need.status);
tmp = attr_mask_and_not(&attr_need_fresh, &p_op->fs_attrs.attr_mask);
p_op->fs_attr_need = attr_mask_or(&p_op->fs_attr_need, &tmp);
if ( !p_op->db_exists )
{
/* new entry */
p_op->db_op_type = OP_TYPE_INSERT;
/* set creation time if it was not set by scan module */
if (!ATTR_MASK_TEST(&p_op->fs_attrs, creation_time))
{
ATTR_MASK_SET( &p_op->fs_attrs, creation_time );
ATTR( &p_op->fs_attrs, creation_time ) = time(NULL); /* XXX min(atime,mtime,ctime)? */
}
#ifdef _LUSTRE
if (ATTR_MASK_TEST(&p_op->fs_attrs, type)
&& !strcmp(ATTR( &p_op->fs_attrs, type ), STR_TYPE_FILE )
/* only if it was not retrieved during the scan */
&& !(ATTR_MASK_TEST(&p_op->fs_attrs, stripe_info)
&& ATTR_MASK_TEST(&p_op->fs_attrs, stripe_items)))
{
attr_mask_set_index(&p_op->fs_attr_need, ATTR_INDEX_stripe_info);
attr_mask_set_index(&p_op->fs_attr_need, ATTR_INDEX_stripe_items);
}
#endif
/* readlink for symlinks (if not already known) */
if (ATTR_MASK_TEST(&p_op->fs_attrs, type)
&& !strcmp(ATTR( &p_op->fs_attrs, type ), STR_TYPE_LINK)
&& !ATTR_MASK_TEST(&p_op->fs_attrs, link))
{
attr_mask_set_index(&p_op->fs_attr_need, ATTR_INDEX_link);
}
else
{
attr_mask_unset_index(&p_op->fs_attr_need, ATTR_INDEX_link);
}
#ifdef ATTR_INDEX_status /** @FIXME RBHv3 drop old-style status reference */
if (ATTR_MASK_TEST(&p_op->fs_attrs, type)
#ifdef _LUSTRE_HSM
&& !strcmp( ATTR(&p_op->fs_attrs, type), STR_TYPE_FILE ))
#elif defined (_HSM_LITE)
&& (strcmp( ATTR(&p_op->fs_attrs, type), STR_TYPE_DIR ) != 0)
&& !p_op->extra_info.not_supp)
#endif
{
p_op->fs_attr_need |= ATTR_MASK_status;
#ifdef _HSM_LITE
p_op->fs_attr_need |= (attr_need_fresh & ~p_op->fs_attrs.attr_mask);
#endif
}
else
{
