int ListMgr_Update( lmgr_t * p_mgr, const entry_id_t * p_id, const attr_set_t * p_update_set )
{
int rc, main_count, annex_count;
char query[4096];
char fields[4096];
char annex_fields[4096];
DEF_PK(pk);
int nb_tables = 0;
/* read only fields in info mask? */
if ( readonly_attr_set & p_update_set->attr_mask )
{
DisplayLog( LVL_MAJOR, LISTMGR_TAG, "Error: trying to update read only values: attr_mask=%#x",
readonly_attr_set & p_update_set->attr_mask );
return DB_INVALID_ARG;
}
rc = entry_id2pk( p_mgr, p_id, FALSE, PTR_PK(pk) );
if (rc)
return rc;
/* check how many tables are to be updated */
if ( main_fields( p_update_set->attr_mask ) )
{
main_count = attrset2updatelist( p_mgr, fields, p_update_set, T_MAIN, FALSE );
if ( main_count < 0 )
return -main_count;
if ( main_count > 0 )
nb_tables++;
}
else
main_count = 0;
if ( annex_table && annex_fields( p_update_set->attr_mask ) )
{
annex_count = attrset2updatelist( p_mgr, annex_fields, p_update_set, T_ANNEX, FALSE );
if ( annex_count < 0 )
return -annex_count;
if ( annex_count > 0 )
nb_tables++;
}
else
annex_count = 0;
if ( stripe_fields( p_update_set->attr_mask ) )
nb_tables += 2;
/* if only 1 table is impacted, switch to autocommit mode */
if ( nb_tables > 1 )
{
/* @todo in the case of sqlite, we may want to do periodic commit
* instead of systematic one. */
rc = lmgr_begin( p_mgr );
if ( rc )
return rc;
}
/* update main table */
if ( main_count > 0 )
{
sprintf( query, "UPDATE " MAIN_TABLE " SET %s WHERE id="DPK, fields, pk );
rc = db_exec_sql( &p_mgr->conn, query, NULL );
if ( rc )
goto rollback;
}
/* update annex table (if any) */
if ( annex_count > 0 )
{
sprintf( query, "UPDATE " ANNEX_TABLE " SET %s WHERE id="DPK, annex_fields, pk );
rc = db_exec_sql( &p_mgr->conn, query, NULL );
if ( rc )
goto rollback;
}
/* insert new stripe info if provided (and eventually remove previous values) */
if ( ATTR_MASK_TEST( p_update_set, stripe_info ) )
{
rc = insert_stripe_info( p_mgr, pk, VALID(p_id), &ATTR( p_update_set, stripe_info ),
ATTR_MASK_TEST( p_update_set, stripe_items ) ?
&ATTR( p_update_set, stripe_items ) : NULL, TRUE );
if ( rc )
goto rollback;
}
if ( nb_tables > 1 )
return lmgr_commit( p_mgr );
else
return DB_SUCCESS;
rollback:
lmgr_rollback( p_mgr );
return rc;
}
static int check_executor(struct sm_instance *smi,
const char *implements,
const policy_action_t *action,
/* arguments for the action : */
const entry_id_t *p_id, attr_set_t *p_attrs,
const action_params_t *params,
post_action_e *what_after, db_cb_func_t db_cb_fn,
void *db_cb_arg)
{
int rc = 0;
time_t t;
bool use_str = false;
GString *out = NULL;
*what_after = PA_UPDATE;
/* Run the action.
* Functions (defined in modules):
* o As input, a function action should use 'output' attribute to compare
* the result of the last execution.
* o As output, a function action can store its result to 'output'
* attribute.
* Commands:
* o As input, a command can retrieve the last output by using '{output}'
* placeholder.
* o As output, output will be set as the contents of stdout
* (truncated to 255 char).
*/
out = g_string_new("");
rc = action_helper(action, "check", p_id, p_attrs, params, smi, out,
what_after, db_cb_fn, db_cb_arg);
/* update the value of last_check */
t = time(NULL);
set_uint_info(smi, p_attrs, ATTR_LAST_CHECK, (unsigned int)t);
/* depending on the action status, update the value of last_success */
if (rc == 0) {
set_status_attr(smi, p_attrs, check_status2str(STATUS_OK));
set_uint_info(smi, p_attrs, ATTR_LAST_SUCCESS, (unsigned int)t);
/* set output if the action was a successful command */
if (action->type == ACTION_COMMAND) {
int rc2;
DisplayLog(LVL_DEBUG, "check_exec", "check command output='%s'",
out->str);
rc2 = set_sm_info(smi, p_attrs, ATTR_OUTPUT, out->str);
if (rc2 == 0)
/* str is now owner by p_attrs */
use_str = true;
}
} else {
set_status_attr(smi, p_attrs, check_status2str(STATUS_FAILED));
DisplayLog(LVL_EVENT, "check_exec",
"check command FAILED on: " DFID_NOBRACE " (%s)",
PFID(p_id), ATTR(p_attrs, fullpath));
}
g_string_free(out, use_str ? FALSE : TRUE);
return rc;
}
static int recov_resume(int retry_errors)
{
struct lmgr_iterator_t *it;
int rc, st;
entry_id_t id, new_id;
attr_set_t attrs, new_attrs;
char buff[128];
/* TODO iter opt */
it = ListMgr_RecovResume(&lmgr, path_filter, retry_errors, NULL);
if (it == NULL) {
fprintf(stderr,
"ERROR: cannot get the list of entries to be recovered\n");
return -1;
}
attrs.attr_mask = RECOV_ATTR_MASK;
while (!terminate &&
((rc =
ListMgr_RecovGetNext(it, &id, &attrs, NULL)) != DB_END_OF_LIST)) {
if (rc) {
fprintf(stderr, "ERROR %d getting entry from recovery table\n", rc);
ListMgr_CloseIterator(it);
return rc;
}
FormatFileSize(buff, 128, ATTR(&attrs, size));
if (ATTR_MASK_TEST(&attrs, fullpath))
printf("Restoring %s (%s)...", ATTR(&attrs, fullpath), buff);
else
printf("Restoring " DFID " (%s)...", PFID(&id), buff);
/* TODO process entries asynchronously, in parallel, in separate
* threads */
st = rbhext_recover(&id, &attrs, &new_id, &new_attrs, NULL);
if ((st == RS_FILE_OK) || (st == RS_FILE_EMPTY) || (st == RS_NON_FILE)
|| (st == RS_FILE_DELTA)) {
/* don't insert readonly attrs */
new_attrs.attr_mask &= ~readonly_attr_set;
/* insert the entry in the database, and update recovery status */
rc = ListMgr_Insert(&lmgr, &new_id, &new_attrs, true);
if (rc) {
fprintf(stderr, "DB insert failure for '%s'\n",
ATTR(&new_attrs, fullpath));
st = RS_ERROR;
}
}
/* old id must be used for impacting recovery table */
if (ListMgr_RecovSetState(&lmgr, &id, st))
st = RS_ERROR;
switch (st) {
case RS_FILE_OK:
printf(" OK\n");
break;
case RS_FILE_DELTA:
printf(" OK (old version)\n");
break;
case RS_NON_FILE:
printf(" OK (non-file)\n");
break;
case RS_FILE_EMPTY:
printf(" OK (empty file)\n");
break;
case RS_NOBACKUP:
printf(" No backup available\n");
break;
case RS_ERROR:
printf(" FAILED\n");
break;
default:
printf(" ERROR st=%d, rc=%d\n", st, rc);
break;
}
/* reset mask */
attrs.attr_mask = RECOV_ATTR_MASK;
}
return 0;
}
/** retrieve directory attributes (nbr of entries, avg size of entries)*/
int listmgr_get_dirattrs( lmgr_t * p_mgr, PK_ARG_T dir_pk, attr_set_t * p_attrs )
{
if (ATTR_MASK_TEST( p_attrs, type) && (strcmp( ATTR(p_attrs, type), STR_TYPE_DIR ) != 0))
{
DisplayLog( LVL_FULL, LISTMGR_TAG, "Type='%s' != 'dir' => unsetting dirattrs in attr mask",
ATTR(p_attrs, type) );
p_attrs->attr_mask &= ~dir_attr_set;
return 0;
}
#ifdef ATTR_INDEX_dircount
char query[1024];
result_handle_t result;
char *str_info[1];
int rc = 0;
int tmp_val;
long long tmp_long;
/* get child entry count from DNAMES_TABLE */
if (ATTR_MASK_TEST(p_attrs, dircount))
{
sprintf( query, "SELECT %s FROM "DNAMES_TABLE" WHERE parent_id="DPK,
dirattr2str(ATTR_INDEX_dircount), dir_pk );
rc = db_exec_sql( &p_mgr->conn, query, &result );
if ( rc )
return rc;
rc = db_next_record( &p_mgr->conn, &result, str_info, 1 );
if (rc == DB_END_OF_LIST)
{
ATTR_MASK_UNSET(p_attrs, dircount);
rc = DB_SUCCESS;
}
else if (rc == DB_SUCCESS)
{
if (str_info[0] == NULL)
/* count(*) should at least return 0 */
rc = DB_REQUEST_FAILED;
else
{
tmp_val = str2int(str_info[0]);
if (tmp_val != -1)
{
ATTR_MASK_SET(p_attrs, dircount);
ATTR( p_attrs, dircount ) = tmp_val;
rc = DB_SUCCESS;
}
else
/* invalid output format */
rc = DB_REQUEST_FAILED;
}
}
db_result_free( &p_mgr->conn, &result );
if (rc)
return rc;
}
/* get avgsize of child entries from MAIN_TABLE */
if (ATTR_MASK_TEST(p_attrs, avgsize))
{
sprintf( query, "SELECT %s FROM "MAIN_TABLE" m, "DNAMES_TABLE" d WHERE m.id = d.id and type='file' and d.parent_id="DPK,
dirattr2str(ATTR_INDEX_avgsize), dir_pk );
rc = db_exec_sql( &p_mgr->conn, query, &result );
if ( rc )
return rc;
rc = db_next_record( &p_mgr->conn, &result, str_info, 1 );
if (rc == DB_END_OF_LIST)
ATTR_MASK_UNSET(p_attrs, avgsize);
else if (rc == DB_SUCCESS)
{
if (str_info[0] == NULL)
{
/* NULL if no entry matches the criteria */
ATTR_MASK_UNSET(p_attrs, avgsize);
rc = DB_SUCCESS;
}
else
{
tmp_long = str2bigint(str_info[0]);
if (tmp_long != -1LL)
{
ATTR_MASK_SET(p_attrs, avgsize);
ATTR( p_attrs, avgsize ) = tmp_long;
rc = DB_SUCCESS;
}
else
/* invalid output format */
rc = DB_REQUEST_FAILED;
}
}
db_result_free( &p_mgr->conn, &result );
}
return rc;
#endif
}
VOID
UiDrawBackdrop(VOID)
{
/* Clear the screen */
MachVideoClearScreen(ATTR(COLOR_WHITE, COLOR_BLACK));
}
void RespondElement::enterElement(const Arabica::DOM::Element<std::string>& node) {
// try to get the request id
if (!HAS_ATTR(node, "to")) {
LOG(ERROR) << "Respond element requires to attribute";
return;
}
if (HAS_ATTR(node, "to") && !_interpreter->getDataModel()) {
LOG(ERROR) << "Respond element with to requires datamodel";
return;
}
std::string requestId = _interpreter->getDataModel().evalAsString(ATTR(node, "to"));
// try to get the request object
InterpreterHTTPServlet* servlet = _interpreter->getHTTPServlet();
tthread::lock_guard<tthread::recursive_mutex> lock(servlet->getMutex());
if (servlet->getRequests().find(requestId) == servlet->getRequests().end()) {
LOG(ERROR) << "No matching HTTP request for respond element";
return;
}
assert(servlet->getRequests().find(requestId) != servlet->getRequests().end());
HTTPServer::Request httpReq = servlet->getRequests()[requestId];
assert(httpReq.evhttpReq != NULL);
HTTPServer::Reply httpReply(httpReq);
servlet->getRequests().erase(requestId);
// get the status or default to 200
std::string statusStr = (HAS_ATTR(node, "status") ? ATTR(node, "status") : "200");
if (!isNumeric(statusStr.c_str(), 10)) {
LOG(ERROR) << "Respond element with non-numeric status " << statusStr;
return;
}
httpReply.status = strTo<int>(statusStr);;
// extract the content
Arabica::XPath::NodeSet<std::string> contents = InterpreterImpl::filterChildElements(_interpreter->getNameSpaceInfo().getXMLPrefixForNS(getNamespace()) + "content", node);
if (contents.size() > 0) {
Arabica::DOM::Element<std::string> contentElem = Arabica::DOM::Element<std::string>(contents[0]);
if (HAS_ATTR(contentElem, "expr")) { // -- content is evaluated string from datamodel ------
if (_interpreter->getDataModel()) {
try {
Data contentData = _interpreter->getDataModel().getStringAsData(ATTR(contentElem, "expr"));
if (contentData.atom.length() > 0) {
httpReply.content = contentData.atom;
httpReply.headers["Content-Type"] = "text/plain";
} else if (contentData.binary) {
httpReply.content = std::string(contentData.binary.getData(), contentData.binary.getSize());
httpReply.headers["Content-Type"] = contentData.binary.getMimeType();
} else if (contentData.node) {
std::stringstream ss;
ss << contentData.node;
httpReply.content = ss.str();;
httpReply.headers["Content-Type"] = "application/xml";
} else {
httpReply.content = Data::toJSON(contentData);
httpReply.headers["Content-Type"] = "application/json";
}
} catch (Event e) {
LOG(ERROR) << "Syntax error with expr in content child of Respond element:" << std::endl << e << std::endl;
return;
}
} else {
LOG(ERROR) << "content element has expr attribute but no datamodel is specified.";
return;
}
} else if (HAS_ATTR(contentElem, "file") || HAS_ATTR(contentElem, "fileexpr")) { // -- content is from file ------
URL file;
if (HAS_ATTR(contentElem, "fileexpr")) {
if (_interpreter->getDataModel()) {
try {
file = "file://" + _interpreter->getDataModel().evalAsString(ATTR(contentElem, "fileexpr"));
} catch (Event e) {
LOG(ERROR) << "Syntax error with fileexpr in content child of Respond element:" << std::endl << e << std::endl;
return;
}
}
} else {
file = "file://" + ATTR(contentElem, "fileexpr");
}
if (file) {
httpReply.content = file.getInContent();
size_t lastDot;
if ((lastDot = file.path().find_last_of(".")) != std::string::npos) {
std::string extension = file.path().substr(lastDot + 1);
std::string mimeType = URL::getMimeType(extension);
if (mimeType.length() > 0) {
httpReply.headers["Content-Type"] = mimeType;
}
}
}
} else if (contents[0].hasChildNodes()) { // -- content embedded as child nodes ------
httpReply.content = contents[0].getFirstChild().getNodeValue();
} else {
LOG(ERROR) << "content element does not specify any content.";
return;
}
}
// process headers
Arabica::XPath::NodeSet<std::string> headers = InterpreterImpl::filterChildElements(_interpreter->getNameSpaceInfo().getXMLPrefixForNS(getNamespace()) + "header", node);
for (int i = 0; i < headers.size(); i++) {
Arabica::DOM::Element<std::string> headerElem = Arabica::DOM::Element<std::string>(headers[i]);
std::string name;
if (HAS_ATTR(headerElem, "name")) {
name = ATTR(headerElem, "name");
} else if(HAS_ATTR(headerElem, "nameexpr")) {
if (_interpreter->getDataModel()) {
try {
name = _interpreter->getDataModel().evalAsString(ATTR(headerElem, "nameexpr"));
} catch (Event e) {
LOG(ERROR) << "Syntax error with nameexpr in header child of Respond element:" << std::endl << e << std::endl;
return;
}
} else {
LOG(ERROR) << "header element has nameexpr attribute but no datamodel is specified.";
return;
}
} else {
LOG(ERROR) << "header element has no name or nameexpr attribute.";
return;
}
std::string value;
if (HAS_ATTR(headerElem, "value")) {
value = ATTR(headerElem, "value");
} else if(HAS_ATTR(headerElem, "valueexpr")) {
if (_interpreter->getDataModel()) {
try {
value = _interpreter->getDataModel().evalAsString(ATTR(headerElem, "valueexpr"));
} catch (Event e) {
LOG(ERROR) << "Syntax error with valueexpr in header child of Respond element:" << std::endl << e << std::endl;
return;
}
} else {
LOG(ERROR) << "header element has valueexpr attribute but no datamodel is specified.";
return;
}
} else {
LOG(ERROR) << "header element has no value or valueexpr attribute.";
return;
}
httpReply.headers[name] = value;
}
// send the reply
HTTPServer::reply(httpReply);
servlet->getRequests().erase(requestId);
}
/* Check if the address is writeable */
BOOLEAN AcpiOsWritable(void* Memory, ACPI_SIZE Length)
{
for(ACPI_SIZE n = 0; n < Length; n += 0x1000){
page_t* page = get_page((void*)((ACPI_SIZE)Memory + n),
0,
current->t_dir);
if( page == NULL ) return FALSE;
if( page->present == 0 ) return FALSE;
if( page->rw == 0 ) return FALSE;
}
return TRUE;
}
/* Read physical memory */
ACPI_STATUS AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address ATTR((unused)),
UINT64* Value ATTR((unused)),
UINT32 Width ATTR((unused)))
{
*Value = 0;
syslog(KERN_ERR, "acpi: %s: method not implemented!", __func__);
return AE_OK;
}
/* Write physical memory */
ACPI_STATUS AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address ATTR((unused)),
UINT64 Value ATTR((unused)),
UINT32 Width ATTR((unused)))
{
syslog(KERN_ERR, "acpi: %s: method not implemented!", __func__);
return AE_OK;
// (pattern) | [ (path)...]
P op_glob(void) {
glob_t gl;
size_t i;
B* curr = FREEvm;
B* top;
P retc = OK;
if (o_1 < FLOORopds) return OPDS_UNF;
if (TAG(o_1) != (ARRAY|BYTETYPE)) return OPD_CLA;
if (curr + ARRAY_SIZE(o_1) + 1 >= CEILvm)
return VM_OVF;
moveB(VALUE_PTR(o_1), curr, ARRAY_SIZE(o_1));
curr += ARRAY_SIZE(o_1);
curr[0] = '\0';
curr = FREEvm;
switch (glob((char*) curr, GLOB_BRACE|GLOB_TILDE, NULL, &gl)) {
case 0: break;
case GLOB_NOMATCH:
if (curr + FRAMEBYTES >= CEILvm) return VM_OVF;
TAG(curr) = LIST;
ATTR(curr) = PARENT;
VALUE_PTR(curr) = LIST_CEIL_PTR(curr) = curr + FRAMEBYTES;
curr += FRAMEBYTES;
moveframe(FREEvm, o_1);
FREEvm = curr;
return OK;
case GLOB_NOSPACE: return MEM_OVF;
case GLOB_ABORTED: return errno ? -errno : READ_ERROR;
default: return UNKNOWN_ERR;
};
if (curr + FRAMEBYTES + FRAMEBYTES * gl.gl_pathc >= CEILvm)
goto vm_ovf;
TAG(curr) = LIST;
ATTR(curr) = PARENT;
VALUE_PTR(curr) = curr + FRAMEBYTES;
top = LIST_CEIL_PTR(curr) = curr + FRAMEBYTES + FRAMEBYTES * gl.gl_pathc;
curr += FRAMEBYTES;
for (i = 0; i < gl.gl_pathc; ++i) {
size_t len = strlen(gl.gl_pathv[i]);
if (top + FRAMEBYTES + DALIGN(len) >= CEILvm) goto vm_ovf;
TAG(top) = (ARRAY|BYTETYPE);
ATTR(top) = PARENT;
VALUE_PTR(top) = top + FRAMEBYTES;
ARRAY_SIZE(top) = len;
moveframe(top, curr);
curr += FRAMEBYTES;
top += FRAMEBYTES;
moveB((B*) gl.gl_pathv[i], top, len);
top += DALIGN(len);
}
moveframe(FREEvm, o_1);
FREEvm = top;
goto exit;
vm_ovf:
retc = VM_OVF;
exit:
globfree(&gl);
return retc;
}
void XmlParser::handleStartElement(void)
{
if (DBG) std::cerr << "StartElement";
if (DBG) std::cerr << ", name: '" << STDR(mXml.name()) << "'" << std::endl;
switch (mCurSection) {
case IGNORED_SECTION:
if (mXml.name() == "chemical_element")
{
mCurSection = ELEMENT_CONFIG_SECTION;
mElement = new Element();
if (!mElement.isNull())
mElement->setProperty(
Element::SYMBOL_PROPERTY,
ATTR(mXml, symbol, StdString)
);
}
break;
case ELEMENT_CONFIG_SECTION:
if (mElement.isNull()) break;
if (mXml.name() == "name") {
mElement->setProperty(
Element::NAME_PROPERTY,
ATTR(mXml, val, StdString)
);
} else if (mXml.name() == "abundance") {
mElement->setProperty(
Element::ABUNDANCE_PROPERTY,
ATTR(mXml, val, Double)
);
} else if (mXml.name() == "atomic_weight") {
mElement->setProperty(
Element::ATOMIC_MASS_PROPERTY,
ATTR(mXml, val, Double)
);
} else if (mXml.name() == "nucleons") {
mElement->setProperty(
Element::NUCLEONS_PROPERTY,
ATTR(mXml, val, Int)
);
} else if (mXml.name() == "electrons") {
mElement->setProperty(
Element::ELECTRONS_PROPERTY,
ATTR(mXml, val, Int)
);
} else if (mXml.name() == "neutron_scattering_length") {
mCurSection = NS_L_SECTION;
} else if (mXml.name() == "neutron_scattering_cross_section") {
mCurSection = NS_C_SECTION;
} else if (mXml.name() == "xray_scattering_anomalous_coefficients") {
mCurSection = XRAY_COEFFICIENTS_SECTION;
}
break;
case NS_L_SECTION:
if (mElement.isNull()) break;
if (mXml.name() == "coherent")
{
mElement->setProperty(
Element::NS_L_COHERENT_PROPERTY,
complex(
ATTR(mXml, re, Double),
ATTR(mXml, im, Double)
));
} else if (mXml.name() == "incoherent")
{
mElement->setProperty(
Element::NS_L_INCOHERENT_PROPERTY,
complex(
ATTR(mXml, re, Double),
ATTR(mXml, im, Double)
));
}
break;
case NS_C_SECTION:
if (mElement.isNull()) break;
if (mXml.name() == "coherent") {
mElement->setProperty(
Element::NS_CS_COHERENT_PROPERTY,
ATTR(mXml, re, Double));
} else if (mXml.name() == "incoherent") {
mElement->setProperty(
Element::NS_CS_INCOHERENT_PROPERTY,
ATTR(mXml, re, Double));
} else if (mXml.name() == "total") {
mElement->setProperty(
Element::NS_CS_TOTAL_PROPERTY,
ATTR(mXml, val, Double) );
} else if (mXml.name() == "absorption") {
mElement->setProperty(
Element::NS_CS_ABSORPTION_PROPERTY,
ATTR(mXml, val, Double) );
}
break;
case XRAY_COEFFICIENTS_SECTION:
if (mElement.isNull()) break;
if (mXml.name() == "ev") {
mElement->addXrayCoefficient(
ATTR(mXml, val, Double),
ATTR(mXml, fp, Double),
ATTR(mXml, fpp, Double) );
}
break;
default:
break;
}
}
void StateTransitionMonitor::beforeEnteringState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
std::cerr << "Entering: " << (HAS_ATTR(state, "id") ? ATTR(state, "id") : DOMUtils::xPathForNode(state)) << std::endl;
}
// void println(string msg)
void METH(s[0], println)(string msg) {
printf("%s(count=%d) %s\n", ATTR(header), PRIVATE.count++, msg);
}
ssize_t ramster_remote_eph_pages_succ_get;
ssize_t ramster_remote_pers_pages_succ_get;
ssize_t ramster_remote_eph_pages_unsucc_get;
ssize_t ramster_remote_pers_pages_unsucc_get;
ssize_t ramster_pers_pages_remote_nomem;
ssize_t ramster_remote_objects_flushed;
ssize_t ramster_remote_object_flushes_failed;
ssize_t ramster_remote_pages_flushed;
ssize_t ramster_remote_page_flushes_failed;
#define ATTR(x) { .name = #x, .val = &ramster_##x, }
static struct debug_entry {
const char *name;
ssize_t *val;
} attrs[] = {
ATTR(eph_pages_remoted),
ATTR(pers_pages_remoted),
ATTR(eph_pages_remote_failed),
ATTR(pers_pages_remote_failed),
ATTR(remote_eph_pages_succ_get),
ATTR(remote_pers_pages_succ_get),
ATTR(remote_eph_pages_unsucc_get),
ATTR(remote_pers_pages_unsucc_get),
ATTR(pers_pages_remote_nomem),
ATTR(remote_objects_flushed),
ATTR(remote_pages_flushed),
ATTR(remote_object_flushes_failed),
ATTR(remote_page_flushes_failed),
ATTR(foreign_eph_pages),
ATTR(foreign_eph_pages_max),
ATTR(foreign_pers_pages),
P op_makewindow(void)
{
#if X_DISPLAY_MISSING
return NO_XWINDOWS;
#else
static XClassHint classhint = {"d_machine", "d_machine"};
static XWMHints xwmhints = {InputHint, False};
static Atom atom[2];
static Atom opaque;
static L32 opaqueval = ~(L32) 0;
P retc;
W *pxy;
B *xyf, *freevm, nstr[31], icstr[13],
*pn[1] = { nstr }, *pic[1] = { icstr };
XSetWindowAttributes attr;
XTextProperty wname, icname;
if (dvtdisplay == NULL) return NO_XWINDOWS;
attr.event_mask = (ButtonPressMask | ExposureMask
| StructureNotifyMask);
attr.override_redirect = False;
if (o_3 < FLOORopds) return OPDS_UNF;
if (TAG(o_1) != (ARRAY | BYTETYPE)) return OPD_ERR;
if (ARRAY_SIZE(o_1) > 12) return RNG_CHK;
moveB((B *)VALUE_BASE(o_1),icstr,ARRAY_SIZE(o_1));
icstr[ARRAY_SIZE(o_1)] = '\000';
if (XStringListToTextProperty((char**) pic,1,&icname) == 0)
return X_ERR;
if (TAG(o_2) != (ARRAY | BYTETYPE)) return OPD_ERR;
if (ARRAY_SIZE(o_2) > 30) return RNG_CHK;
moveB((B *)VALUE_BASE(o_2),nstr,ARRAY_SIZE(o_2));
nstr[ARRAY_SIZE(o_2)] = '\000';
if (XStringListToTextProperty((char**)pn,1,&wname) == 0)
return X_ERR;
FREEopds = o_2;
freevm = FREEvm;
if ((retc = xy(&xyf,&freevm)) != OK) return retc;
pxy = (W *)VALUE_BASE(xyf);
if (ARRAY_SIZE(xyf) != 4) return RNG_CHK;
if (ndvtwindows >= MAXDVTWINDOWS) return RNG_CHK;
wid = HXCreateWindow(dvtdisplay, dvtrootwindow, pxy[0], pxy[1],
pxy[2], pxy[3], 0, CopyFromParent,
InputOutput, CopyFromParent,
CWEventMask, &attr);
HXSetWMProperties(dvtdisplay, wid,
&wname, &icname,
NULL, 0,
NULL, &xwmhints, &classhint);
atom[0] = HXInternAtom(dvtdisplay, "WM_DELETE_WINDOW", False);
atom[1] = HXInternAtom(dvtdisplay, "WM_TAKE_FOCUS", False);
HXSetWMProtocols(dvtdisplay, wid, atom, 2);
opaque = HXInternAtom(dvtdisplay, "_KDE_WM_WINDOW_OPACITY", False);
HXChangeProperty(dvtdisplay, wid, opaque, XA_CARDINAL, 32,
PropModeReplace, (unsigned char*) &opaqueval, 1);
dvtwindows[ndvtwindows++] = wid;
TAG(o1) = NUM | LONGBIGTYPE;
ATTR(o1) = 0;
LONGBIG_VAL(o1) = wid;
FREEopds = o2;
return OK;
#endif
}
#include <linux/atomic.h>
#include "debug.h"
#ifdef CONFIG_ZCACHE_DEBUG
#include <linux/debugfs.h>
#define ATTR(x) { .name = #x, .val = &zcache_##x, }
static struct debug_entry {
const char *name;
ssize_t *val;
} attrs[] = {
ATTR(obj_count), ATTR(obj_count_max),
ATTR(objnode_count), ATTR(objnode_count_max),
ATTR(flush_total), ATTR(flush_found),
ATTR(flobj_total), ATTR(flobj_found),
ATTR(failed_eph_puts), ATTR(failed_pers_puts),
ATTR(failed_getfreepages), ATTR(failed_alloc),
ATTR(put_to_flush),
ATTR(compress_poor), ATTR(mean_compress_poor),
ATTR(eph_ate_tail), ATTR(eph_ate_tail_failed),
ATTR(pers_ate_eph), ATTR(pers_ate_eph_failed),
ATTR(evicted_eph_zpages), ATTR(evicted_eph_pageframes),
ATTR(eph_pageframes), ATTR(eph_pageframes_max),
ATTR(eph_zpages), ATTR(eph_zpages_max),
ATTR(pers_zpages), ATTR(pers_zpages_max),
ATTR(last_active_file_pageframes),
ATTR(last_inactive_file_pageframes),
ATTR(last_active_anon_pageframes),
ATTR(last_inactive_anon_pageframes),
ATTR(eph_nonactive_puts_ignored),
ATTR(pers_nonactive_puts_ignored),
void XPathDataModel::assign(const Element<std::string>& assignElem,
const Node<std::string>& node,
const std::string& content) {
std::string location;
if (HAS_ATTR(assignElem, "id")) {
location = ATTR(assignElem, "id");
} else if (HAS_ATTR(assignElem, "location")) {
location = ATTR(assignElem, "location");
}
// test 326ff
XPathValue<std::string> key = _xpath.evaluate_expr(location, _doc);
#ifdef VERBOSE
LOG(INFO) << "Key XPath : " << key.asString();
#endif
#if 0
if (key.type() == NODE_SET) {
try {
for (size_t i = 0; i < key.asNodeSet().size(); i++) {
Node<std::string> node = key.asNodeSet()[i];
if (node == _varResolver.resolveVariable("", "_ioprocessors").asNodeSet()[0])
ERROR_EXECUTION_THROW("Cannot assign _ioProcessors");
if (node == _varResolver.resolveVariable("", "_sessionid").asNodeSet()[0])
ERROR_EXECUTION_THROW("Cannot assign _sessionid");
if (node == _varResolver.resolveVariable("", "_name").asNodeSet()[0])
ERROR_EXECUTION_THROW("Cannot assign _name");
if (node == _varResolver.resolveVariable("", "_event").asNodeSet()[0])
ERROR_EXECUTION_THROW("Cannot assign _event");
}
} catch (Event e) {}
}
#endif
NodeSet<std::string> nodeSet;
if (node) {
Node<std::string> data = node;
while (data) {
// do not add empty text as a node
if (data.getNodeType() == Node_base::TEXT_NODE) {
std::string trimmed = data.getNodeValue();
boost::trim(trimmed);
if (trimmed.length() == 0) {
data = data.getNextSibling();
continue;
}
}
nodeSet.push_back(data);
data = data.getNextSibling();
}
assign(key, nodeSet, assignElem);
} else if (content.length() > 0) {
Text<std::string> textNode = _doc.createTextNode(spaceNormalize(content));
nodeSet.push_back(textNode);
assign(key, nodeSet, assignElem);
} else if (HAS_ATTR(assignElem, "expr")) {
XPathValue<std::string> value = _xpath.evaluate_expr(ATTR(assignElem, "expr"), _doc);
#ifdef VERBOSE
LOG(INFO) << "Value XPath : " << value.asString();
#endif
assign(key, value, assignElem);
} else {
LOG(ERROR) << "assign element has no content";
}
// std::cout << _datamodel << std::endl;
}
int result2attrset( table_enum table, char **result_tab,
unsigned int res_count, attr_set_t * p_set )
{
int i;
unsigned int nbfields = 0;
db_type_u typeu;
int mask = 1;
for ( i = 0; i < ATTR_COUNT; i++, mask <<= 1 )
{
if ( ( p_set->attr_mask & mask ) && ( MATCH_TABLE( table, i ) ) )
{
#ifdef _DEBUG_DB
DisplayLog( LVL_FULL, LISTMGR_TAG, "result[%u] = %s", nbfields, result_tab[nbfields] );
#endif
/* Parse nbfield'th value */
if ( nbfields >= res_count )
{
return DB_BUFFER_TOO_SMALL;
}
if ( (result_tab == NULL) || (result_tab[nbfields] == NULL) )
{
p_set->attr_mask &= ~( 1 << i );
nbfields++;
continue;
}
if ( field_infos[i].db_type == DB_STRIPE_INFO )
{
if ( result_tab[nbfields] == NULL
|| result_tab[nbfields+1] == NULL
|| result_tab[nbfields+2] == NULL )
{
p_set->attr_mask &= ~( 1 << i );
nbfields+=3;
continue;
}
ATTR(p_set, stripe_info).stripe_count = atoi( result_tab[nbfields] );
ATTR(p_set, stripe_info).stripe_size = atoi( result_tab[nbfields+1] );
strncpy( ATTR(p_set, stripe_info).pool_name, result_tab[nbfields+2] , MAX_POOL_LEN );
ATTR(p_set, stripe_info).pool_name[MAX_POOL_LEN-1] = 0;
/* stripe count, stripe size and pool_name */
nbfields += 3;
continue;
}
else if ( !parsedbtype( result_tab[nbfields], field_infos[i].db_type, &typeu ) )
{
DisplayLog( LVL_CRIT, LISTMGR_TAG,
"Error: cannot parse field value '%s'", result_tab[nbfields] );
p_set->attr_mask &= ~( 1 << i );
nbfields++;
continue;
}
UNION_GET_VALUE( typeu, field_infos[i].db_type,
( ( char * ) &p_set->attr_values + field_infos[i].offset ) );
nbfields++;
}
}
return 0;
}
void XPathDataModel::assign(const Element<std::string>& key,
const NodeSet<std::string>& value,
const Element<std::string>& assignElem) {
Element<std::string> element(key);
if (value.size() == 0 || !value[0])
return;
if (false) {
} else if (assignElem && HAS_ATTR(assignElem, "type") && iequals(ATTR(assignElem, "type"), "firstchild")) {
// firstchild: Insert the value specified by 'expr' before all of the children at 'location'.
for (size_t i = value.size(); i; i--) {
Node<std::string> importedNode = (value[i-1].getOwnerDocument() == _doc ? value[i-1].cloneNode(true) : _doc.importNode(value[i-1], true));
element.insertBefore(importedNode, element.getFirstChild());
}
} else if (assignElem && HAS_ATTR(assignElem, "type") && iequals(ATTR(assignElem, "type"), "lastchild")) {
// lastchild: Insert the value specified by 'expr' after all of the children at 'location'.
for (size_t i = 0; i < value.size(); i++) {
Node<std::string> importedNode = (value[i].getOwnerDocument() == _doc ? value[i].cloneNode(true) : _doc.importNode(value[i], true));
element.appendChild(importedNode);
}
} else if (assignElem && HAS_ATTR(assignElem, "type") && iequals(ATTR(assignElem, "type"), "previoussibling")) {
// previoussibling: Insert the value specified by 'expr' before the
// node specified by 'location', keeping the same parent.
Node<std::string> parent = element.getParentNode();
if (!parent)
ERROR_EXECUTION_THROW("Node has no parent");
for (size_t i = 0; i < value.size(); i++) {
Node<std::string> importedNode = (value[i].getOwnerDocument() == _doc ? value[i].cloneNode(true) : _doc.importNode(value[i], true));
parent.insertBefore(importedNode, element);
}
} else if (assignElem && HAS_ATTR(assignElem, "type") && iequals(ATTR(assignElem, "type"), "nextsibling")) {
// nextsibling: Insert the value specified by 'expr' after the node
// specified by 'location', keeping the same parent.
Node<std::string> parent = element.getParentNode();
if (!parent)
ERROR_EXECUTION_THROW("Node has no parent");
for (size_t i = value.size(); i; i--) {
Node<std::string> importedNode = (value[i-1].getOwnerDocument() == _doc ? value[i-1].cloneNode(true) : _doc.importNode(value[i-1], true));
Node<std::string> nextSibling = element.getNextSibling();
if (nextSibling) {
parent.insertBefore(importedNode, element.getNextSibling());
} else {
parent.appendChild(importedNode);
}
}
} else if (assignElem && HAS_ATTR(assignElem, "type") && iequals(ATTR(assignElem, "type"), "replace")) {
// replace: Replace the node specified by 'location' by the value specified by 'expr'.
Node<std::string> parent = element.getParentNode();
if (!parent)
ERROR_EXECUTION_THROW("Node has no parent");
if (value.size() != 1)
ERROR_EXECUTION_THROW("Value not singular");
Node<std::string> importedNode = (value[0].getOwnerDocument() == _doc ? value[0].cloneNode(true) : _doc.importNode(value[0], true));
parent.replaceChild(importedNode, element);
} else if (assignElem && HAS_ATTR(assignElem, "type") && iequals(ATTR(assignElem, "type"), "delete")) {
// delete: Delete the node specified by 'location'. ('expr' is ignored.).
Node<std::string> parent = element.getParentNode();
if (!parent)
ERROR_EXECUTION_THROW("Node has no parent");
parent.removeChild(element);
} else {
// replacechildren: Replace all the children at 'location' with the value specified by 'expr'.
while(element.hasChildNodes())
element.removeChild(element.getChildNodes().item(0));
for (size_t i = 0; i < value.size(); i++) {
Node<std::string> importedNode = element.getOwnerDocument().importNode(value[i], true);
element.appendChild(importedNode);
}
}
}
int main(void)
{
LBIG memsetup[5] = { 1000, 100, 20, 10, 200 };
B* startup_dvt;
B fromconsoleframe[FRAMEBYTES], *sf;
P nb, retc,tnb;
B *sysdict, *userdict, *p;
int sufd;
sysop = _sysop;
syserrc = _syserrc;
syserrm = _syserrm;
createfds();
serialized = TRUE; // no serialize operator
/*----------------- SIGNALS that we wish to handle -------------------*/
/* FPU indigestion is recorded in the numovf flag;
we do not wish to be killed by it
*/
numovf = FALSE;
signal(SIGFPE, SIGFPEhandler);
/* The broken pipe signal is ignored, so it cannot kill us;
it will pop up in attempts to send on a broken connection
*/
signal(SIGPIPE, SIG_IGN);
/* We use alarms to time-limit read/write operations on sockets */
timeout = FALSE;
signal(SIGALRM, SIGALRMhandler);
/* The interrupt signal is produced by the control-c key of the
console keyboard, it triggers the execution of 'abort'
*/
abortflag = FALSE;
signal(SIGINT, SIGINThandler);
/*--------------------- set up the tiny D machine -------------------
Not so tiny for the dvt, this should be good for most work
*/
if (makeDmemory(memsetup))
dm_error(0, "D memory");
/*----------------- construct frames for use in execution of D code */
makename((B*) "error", errorframe);
ATTR(errorframe) = ACTIVE;
makename((B*) "fromconsole", fromconsoleframe);
ATTR(fromconsoleframe) = ACTIVE;
TAG(FREEvm) = STRING;
ARRAY_SIZE(FREEvm) = 1024;
VALUE_PTR(FREEvm) = FREEvm + FRAMEBYTES;
ATTR(FREEvm) = ACTIVE;
moveframe(FREEvm, inputframe);
FREEvm += FRAMEBYTES + 1024;
/* The system dictionary is created in the workspace of the tiny D machine.
If the operator 'makeVM' is used to create a large D machine, this larger
machine inherits the system dictionary of the tiny machine. We memorize
the pointers of the tiny D memory so we can revert to the tiny setup.
*/
if ((sysdict = makeopdict((B *)sysop, syserrc, syserrm)) == (B *)(-1L))
dm_error(0,"Cannot make system dictionary");
if ((userdict = makedict(memsetup[4])) == (B *)(-1L))
dm_error(0,"Cannot make user dictionary");
/* The first two dictionaries on the dicts are systemdict and userdict;
they are not removable
*/
moveframe (sysdict-FRAMEBYTES,FREEdicts);
FREEdicts += FRAMEBYTES;
moveframe (userdict-FRAMEBYTES,FREEdicts);
FREEdicts += FRAMEBYTES;
setupdirs();
fprintf(stderr, "Startup dir: %s\n", startup_dir);
/*----------- read startup_dvt.d and push on execs ----------*/
startup_dvt
= (B*)strcat(strcpy(malloc(strlen((char*)startup_dir)
+ strlen("/startup_dgen.d") + 1),
startup_dir),
"/startup_dgen.d");
if ((sufd = open((char*)startup_dvt, O_RDONLY)) == -1)
dm_error(errno,"Opening %s", startup_dvt);
tnb = 0; sf = FREEvm; p = sf + FRAMEBYTES;
TAG(sf) = ARRAY | BYTETYPE; ATTR(sf) = READONLY | ACTIVE | PARENT;
VALUE_BASE(sf) = (P)p;
while (((nb = read(sufd,p,CEILvm-p)) > 0) && (p <= CEILvm)) {
tnb += nb;
p += nb;
}
if (nb == -1) dm_error(errno,"Reading %s", startup_dvt);
if (p == CEILvm) dm_error(ENOMEM,"%s > VM", startup_dvt);
ARRAY_SIZE(sf) = tnb;
FREEvm += DALIGN(FRAMEBYTES + tnb);
moveframe(sf,x1);
FREEexecs = x2;
/*-------------------------- run the D mill --------------------- */
while (1) {
switch(retc = exec(1000)) {
case MORE: continue;
case DONE:
moveframe(fromconsoleframe, x1);
FREEexecs=x2;
continue;
case ABORT:
printf("Failure...\n");
exitval = ((UL32) EXIT_FAILURE) & 0xFF;
die();
case QUIT: case TERM:
printf("Success..\n");
die();
default: break;
}
/*----------------------- error handler ---------------------------*/
makeerror(retc, errsource);
};
} /* of main */
void
GLLibraryEGL::DumpEGLConfig(EGLConfig cfg)
{
int attrval;
int err;
#define ATTR(_x) do { \
fGetConfigAttrib(mEGLDisplay, cfg, LOCAL_EGL_##_x, &attrval); \
if ((err = fGetError()) != 0x3000) { \
printf_stderr(" %s: ERROR (0x%04x)\n", #_x, err); \
} else { \
printf_stderr(" %s: %d (0x%04x)\n", #_x, attrval, attrval); \
} \
} while(0)
printf_stderr("EGL Config: %d [%p]\n", (int)(intptr_t)cfg, cfg);
ATTR(BUFFER_SIZE);
ATTR(ALPHA_SIZE);
ATTR(BLUE_SIZE);
ATTR(GREEN_SIZE);
ATTR(RED_SIZE);
ATTR(DEPTH_SIZE);
ATTR(STENCIL_SIZE);
ATTR(CONFIG_CAVEAT);
ATTR(CONFIG_ID);
ATTR(LEVEL);
ATTR(MAX_PBUFFER_HEIGHT);
ATTR(MAX_PBUFFER_PIXELS);
ATTR(MAX_PBUFFER_WIDTH);
ATTR(NATIVE_RENDERABLE);
ATTR(NATIVE_VISUAL_ID);
ATTR(NATIVE_VISUAL_TYPE);
ATTR(PRESERVED_RESOURCES);
ATTR(SAMPLES);
ATTR(SAMPLE_BUFFERS);
ATTR(SURFACE_TYPE);
ATTR(TRANSPARENT_TYPE);
ATTR(TRANSPARENT_RED_VALUE);
ATTR(TRANSPARENT_GREEN_VALUE);
ATTR(TRANSPARENT_BLUE_VALUE);
ATTR(BIND_TO_TEXTURE_RGB);
ATTR(BIND_TO_TEXTURE_RGBA);
ATTR(MIN_SWAP_INTERVAL);
ATTR(MAX_SWAP_INTERVAL);
ATTR(LUMINANCE_SIZE);
ATTR(ALPHA_MASK_SIZE);
ATTR(COLOR_BUFFER_TYPE);
ATTR(RENDERABLE_TYPE);
ATTR(CONFORMANT);
#undef ATTR
}
VOID
MiniTuiDrawMenu(PUI_MENU_INFO MenuInfo)
{
ULONG i;
//
// Draw the backdrop
//
UiDrawBackdrop();
//
// No GUI status bar text, just minimal text. Show the menu header.
//
UiVtbl.DrawText(0,
MenuInfo->Top - 2,
MenuInfo->MenuHeader,
ATTR(UiMenuFgColor, UiMenuBgColor));
//
// Now tell the user how to choose
//
UiVtbl.DrawText(0,
MenuInfo->Bottom + 1,
"Use \x18 and \x19 to move the highlight to your choice.",
ATTR(UiMenuFgColor, UiMenuBgColor));
UiVtbl.DrawText(0,
MenuInfo->Bottom + 2,
"Press ENTER to choose.",
ATTR(UiMenuFgColor, UiMenuBgColor));
//
// And show the menu footer
//
UiVtbl.DrawText(0,
UiScreenHeight - 4,
MenuInfo->MenuFooter,
ATTR(UiMenuFgColor, UiMenuBgColor));
//
// Draw the menu box
//
TuiDrawMenuBox(MenuInfo);
//
// Draw each line of the menu
//
for (i = 0; i < MenuInfo->MenuItemCount; i++)
{
TuiDrawMenuItem(MenuInfo, i);
}
//
// Display the boot options if needed
//
if (MenuInfo->ShowBootOptions)
{
DisplayBootTimeOptions();
}
VideoCopyOffScreenBufferToVRAM();
}
/**
* Retrieve entry attributes from its primary key
*/
int listmgr_get_by_pk( lmgr_t * p_mgr, PK_ARG_T pk, attr_set_t * p_info )
{
int rc;
char fieldlist[4096] = "";
char *first_table = NULL;
char from[1024] = "";
char query[4096] = "";
/* we assume there is not more than 128 fields */
char *result_tab[128];
result_handle_t result;
int checkmain = 1;
int main_count = 0, annex_count = 0, name_count = 0;
if (p_info == NULL)
return 0;
/* init entry info */
memset( &p_info->attr_values, 0, sizeof( entry_info_t ) );
fieldlist[0] = '\0';
/* retrieve source info for generated fields */
add_source_fields_for_gen( &p_info->attr_mask );
/* get info from main table (if asked) */
main_count = attrmask2fieldlist(fieldlist, p_info->attr_mask, T_MAIN, FALSE,
FALSE, "", "");
if (main_count < 0)
return -main_count;
else if (main_count > 0)
{
checkmain = 0;
first_table = MAIN_TABLE;
sprintf(from, MAIN_TABLE);
}
annex_count = attrmask2fieldlist(fieldlist + strlen(fieldlist),
p_info->attr_mask, T_ANNEX,
first_table != NULL, FALSE, "", "");
if (annex_count < 0)
return -annex_count;
else if (annex_count > 0)
{
if (first_table)
sprintf(from + strlen(from), " LEFT JOIN "ANNEX_TABLE" ON %s.id="
ANNEX_TABLE".id", first_table);
else
{
first_table = ANNEX_TABLE;
sprintf(from, ANNEX_TABLE);
}
}
name_count = attrmask2fieldlist(fieldlist + strlen(fieldlist),
p_info->attr_mask, T_DNAMES,
first_table != NULL, FALSE, "", "");
if (name_count < 0)
return -name_count;
else if (name_count > 0)
{
if (first_table)
/* it's OK to JOIN with NAMES table here even if there are multiple paths,
* as we only take one result record. The important thing is to return
* consistent values for parent_id, name and fullpath. */
sprintf(from + strlen(from), " LEFT JOIN "DNAMES_TABLE" ON %s.id="
DNAMES_TABLE".id", first_table);
else
{
first_table = DNAMES_TABLE;
sprintf(from, DNAMES_TABLE);
}
}
if (first_table != NULL)
{
int shift = 0;
sprintf(query, "SELECT %s FROM %s WHERE %s.id="DPK, fieldlist, from,
first_table, pk);
rc = db_exec_sql(&p_mgr->conn, query, &result);
if (rc)
return rc;
rc = db_next_record(&p_mgr->conn, &result, result_tab,
main_count + annex_count + name_count);
/* END_OF_LIST means it does not exist */
if (rc == DB_END_OF_LIST)
rc = DB_NOT_EXISTS;
if (rc)
goto free_res;
/* set info from result */
if (main_count)
{
rc = result2attrset(T_MAIN, result_tab + shift, main_count, p_info);
shift += main_count;
if (rc)
goto free_res;
}
if (annex_count)
{
rc = result2attrset(T_ANNEX, result_tab + shift, annex_count,
p_info);
shift += annex_count;
if (rc)
goto free_res;
}
if (name_count)
{
rc = result2attrset(T_DNAMES, result_tab + shift, name_count,
p_info);
shift += name_count;
if (rc)
goto free_res;
}
db_result_free(&p_mgr->conn, &result);
}
/* remove stripe info if it is not a file */
if (stripe_fields(p_info->attr_mask) && ATTR_MASK_TEST(p_info, type)
&& strcmp(ATTR(p_info, type), STR_TYPE_FILE) != 0)
{
p_info->attr_mask &= ~stripe_attr_set;
}
/* get stripe info if asked */
#ifdef _LUSTRE
if (stripe_fields( p_info->attr_mask ))
{
rc = get_stripe_info( p_mgr, pk, &ATTR( p_info, stripe_info ),
ATTR_MASK_TEST( p_info, stripe_items ) ? &ATTR( p_info,
stripe_items ) :
NULL );
if ( rc == DB_ATTR_MISSING || rc == DB_NOT_EXISTS )
{
p_info->attr_mask &= ~ATTR_MASK_stripe_info;
if ( ATTR_MASK_TEST( p_info, stripe_items ) )
p_info->attr_mask &= ~ATTR_MASK_stripe_items;
}
else if ( rc )
return rc;
else
checkmain = 0; /* entry exists */
}
#else
/* always clean them */
p_info->attr_mask &= ~(ATTR_MASK_stripe_info | ATTR_MASK_stripe_items);
#endif
/* special field dircount */
if (dirattr_fields( p_info->attr_mask ))
{
if (listmgr_get_dirattrs(p_mgr, pk, p_info))
{
DisplayLog( LVL_MAJOR, LISTMGR_TAG, "listmgr_get_dirattrs failed for "DPK, pk );
p_info->attr_mask &= ~dir_attr_set;
}
}
if (checkmain)
{
/* verify it exists in main table */
sprintf( query, "SELECT id FROM " MAIN_TABLE " WHERE id="DPK, pk );
/* execute the request */
rc = db_exec_sql( &p_mgr->conn, query, &result );
if ( rc )
return rc;
rc = db_next_record( &p_mgr->conn, &result, result_tab, 1 );
db_result_free( &p_mgr->conn, &result );
if (rc)
return DB_NOT_EXISTS;
}
/* compute generated fields if asked */
generate_fields( p_info );
p_mgr->nbop[OPIDX_GET]++;
return DB_SUCCESS;
free_res:
db_result_free( &p_mgr->conn, &result );
return rc;
} /* listmgr_get_by_pk */
/**
* List the content of the given id/path list
*/
static int list_content(char ** id_list, int id_count)
{
wagon_t *ids;
int i, rc;
attr_set_t root_attrs;
entry_id_t root_id;
int is_id;
rc = get_root_id(&root_id);
if (rc)
return rc;
ids = MemCalloc(id_count, sizeof(wagon_t));
if (!ids)
return -ENOMEM;
for (i = 0; i < id_count; i++)
{
is_id = TRUE;
/* is it a path or fid? */
if (sscanf(id_list[i], SFID, RFID(&ids[i].id)) != FID_SCAN_CNT)
{
is_id = FALSE;
/* take it as a path */
rc = Path2Id(id_list[i], &ids[i].id);
if (!rc) {
ids[i].fullname = id_list[i];
if (FINAL_SLASH(ids[i].fullname))
REMOVE_FINAL_SLASH(ids[i].fullname);
}
} else {
#if _HAVE_FID
/* Take it as an FID. */
char path[RBH_PATH_MAX];
rc = Lustre_GetFullPath( &ids[i].id, path, sizeof(path));
if (!rc)
ids[i].fullname = strdup(path);
#endif
}
if (rc) {
DisplayLog(LVL_MAJOR, FIND_TAG, "Invalid parameter: %s: %s",
id_list[i], strerror(-rc));
goto out;
}
/* get root attrs to print it (if it matches program options) */
root_attrs.attr_mask = disp_mask | query_mask;
rc = ListMgr_Get(&lmgr, &ids[i].id, &root_attrs);
if (rc == 0)
dircb(&ids[i], &root_attrs, 1, NULL);
else
{
DisplayLog(LVL_VERB, FIND_TAG, "Notice: no attrs in DB for %s", id_list[i]);
if (!is_id)
{
struct stat st;
ATTR_MASK_SET(&root_attrs, fullpath);
strcpy(ATTR(&root_attrs, fullpath), id_list[i]);
if (lstat(ATTR(&root_attrs, fullpath ), &st) == 0)
{
PosixStat2EntryAttr(&st, &root_attrs, TRUE);
ListMgr_GenerateFields( &root_attrs, disp_mask | query_mask);
}
}
else if (entry_id_equal(&ids[i].id, &root_id))
{
/* this is root id */
struct stat st;
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);
}
}
dircb(&ids[i], &root_attrs, 1, NULL);
}
rc = rbh_scrub(&lmgr, &ids[i], 1, disp_mask | query_mask, dircb, NULL);
}
out:
/* ids have been processed, free them */
MemFree(ids);
return rc;
}
VOID
NTAPI
UiDrawMenuBox(IN PUI_MENU_INFO MenuInfo)
{
CHAR MenuLineText[80], TempString[80];
ULONG i;
/* If there is a timeout draw the time remaining */
if (MenuInfo->MenuTimeRemaining >= 0)
{
/* Copy the integral time text string, and remove the last 2 chars */
strcpy(TempString, UiTimeText);
i = strlen(TempString);
TempString[i - 2] = 0;
/* Display the first part of the string and the remaining time */
strcpy(MenuLineText, TempString);
_itoa(MenuInfo->MenuTimeRemaining, TempString, 10);
strcat(MenuLineText, TempString);
/* Add the last 2 chars */
strcat(MenuLineText, &UiTimeText[i - 2]);
/* Display under the menu directly */
UiDrawText(0,
MenuInfo->Bottom + 4,
MenuLineText,
ATTR(UiMenuFgColor, UiMenuBgColor));
}
else
{
/* Erase the timeout string with spaces, and 0-terminate for sure */
for (i=0; i<sizeof(MenuLineText)-1; i++)
{
MenuLineText[i] = ' ';
}
MenuLineText[sizeof(MenuLineText)-1] = 0;
/* Draw this "empty" string to erase */
UiDrawText(0,
MenuInfo->Bottom + 4,
MenuLineText,
ATTR(UiMenuFgColor, UiMenuBgColor));
}
/* Loop each item */
for (i = 0; i < MenuInfo->MenuItemCount; i++)
{
/* Check if it's a separator */
if (MenuInfo->MenuItemList[i] == NULL)
{
/* Draw the separator line */
UiDrawText(MenuInfo->Left,
MenuInfo->Top + i + 1,
"\xC7",
ATTR(UiMenuFgColor, UiMenuBgColor));
UiDrawText(MenuInfo->Right,
MenuInfo->Top + i + 1,
"\xB6",
ATTR(UiMenuFgColor, UiMenuBgColor));
}
}
}
/**
* 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 = get_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;
}
const char * name;
const char * graphPath;
const char * childPath;
const char * dft;
};
#define CHILDPATH(x) "att[@name='" x "']/@value"
#define ATTR(kind, measure, path) { WA ## kind, measure, #kind, path, nullptr, nullptr }
#define CHILD(kind, measure, path) { WA ## kind, measure, #kind, CHILDPATH(path), path, nullptr }
#define CHILD_D(kind, measure, path, dft) { WA ## kind, measure, #kind, CHILDPATH(path), path, dft }
const static WuAttrInfo attrInfo[] = {
{ WANone, SMeasureNone, "none", nullptr, nullptr, nullptr },
CHILD(Kind, SMeasureEnum, "_kind"),
ATTR(Source, SMeasureText, "@source"),
ATTR(Target, SMeasureText, "@target"),
CHILD_D(SourceIndex, SMeasureText, "_sourceIndex", "0"),
CHILD_D(TargetIndex, SMeasureText, "_targetIndex", "0"),
ATTR(Label, SMeasureText, "@label"),
CHILD(IsDependency, SMeasureBool, "_dependsOn"),
CHILD(IsChildGraph, SMeasureBool, "_childGraph"),
CHILD(Definition, SMeasureText, "definition"),
CHILD(EclName, SMeasureText, "name"),
{ WAMax, SMeasureNone, nullptr, nullptr, nullptr, nullptr }
};
MODULE_INIT(INIT_PRIORITY_STANDARD)
{
static_assert(_elements_in(attrInfo) >= (WAMax-WANone)+1, "Elements missing from attrInfo[]");
static inline void print_entry(const wagon_t *id, const attr_set_t * attrs)
{
#ifdef ATTR_INDEX_status
if (prog_options.match_status)
{
if (ATTR_MASK_TEST(attrs, status) && (ATTR(attrs, status) != prog_options.status))
{
/* no match -> no display */
return;
}
}
#endif
if (prog_options.ls)
{
const char * type;
char date_str[128];
char mode_str[128];
char uname[LOGIN_NAME_MAX];
char gname[LOGIN_NAME_MAX];
struct passwd *passwd;
struct group *group;
#ifdef ATTR_INDEX_status
const char * status_str = "";
/* add status after type */
if (ATTR_MASK_TEST(attrs, status) && (ATTR(attrs, status) != STATUS_UNKNOWN))
status_str = db_status2str(ATTR(attrs, status), 1); /* 1 for brief */
#define STATUS_FORMAT "%-10s"
#define STATUS_VAL ,status_str
#else
#define STATUS_FORMAT ""
#define STATUS_VAL
#endif
/* type2char */
if (!ATTR_MASK_TEST(attrs, type))
type = "?";
else
type = type2char(ATTR(attrs, type));
memset(mode_str, 0, sizeof(mode_str));
mode_string(ATTR(attrs, mode), mode_str);
if (!ATTR_MASK_TEST(attrs, last_mod))
strcpy(date_str, "");
else
{
time_t tt;
struct tm stm;
tt = ATTR(attrs, last_mod);
strftime(date_str, 128, "%Y/%m/%d %T", localtime_r(&tt, &stm));
}
/* UID/GID to username/group. */
passwd = GetPwUid(ATTR(attrs, uid));
if (passwd)
sprintf(uname, "%-10s", passwd->pw_name);
else
sprintf(uname, "%10u", ATTR(attrs, uid));
group = GetGrGid(ATTR(attrs, gid));
if (group)
sprintf(gname, "%-10s", group->gr_name);
else
sprintf(gname, "%10u", ATTR(attrs, gid));
if (ATTR_MASK_TEST(attrs, type) && !strcmp(ATTR(attrs, type), STR_TYPE_LINK)
&& ATTR_MASK_TEST(attrs, link))
/* display: id, type, mode, nlink, (status,) owner, group, size, mtime, path -> link */
printf(DFID" %-4s %s %3u "STATUS_FORMAT"%-10s %-10s %15"PRIu64" %20s %s -> %s\n",
PFID(&id->id), type, mode_str, ATTR(attrs, nlink) STATUS_VAL,
uname, gname,
ATTR(attrs, size), date_str, id->fullname, ATTR(attrs,link));
else
/* display all: id, type, mode, nlink, (status,) owner, group, size, mtime, path */
printf(DFID" %-4s %s %3u "STATUS_FORMAT"%-10s %-10s %15"PRIu64" %20s %s\n",
PFID(&id->id), type, mode_str, ATTR(attrs, nlink) STATUS_VAL,
uname, gname,
ATTR(attrs, size), date_str, id->fullname);
}
else if (prog_options.lsstat)
{
/* In the worst case scenario, each character will be escaped
* to '\xXX'; so the string can be up to 4 time the name
* length. */
char escaped_name[4*RBH_NAME_MAX+1];
/* Exclude any file with an uncomplete attributes. */
if ((attrs->attr_mask & LSSTAT_MASK) == LSSTAT_MASK) {
printf("[%s,%u,%u,%zu,%lu,%lu,%lu]=%s\n",
ATTR(attrs, type),
ATTR(attrs, uid),
ATTR(attrs, gid),
ATTR(attrs, size),
ATTR(attrs, ctime),
ATTR(attrs, mtime),
ATTR(attrs, atime),
escape_name(id->fullname, escaped_name));
} else {
printf("SKIPPED(%x,%x)=%s\n", attrs->attr_mask, LSSTAT_MASK, id->fullname);
}
}
#ifdef _LUSTRE
else if (prog_options.lsost) {
char tmpbuf[24576];
FormatStripeList( tmpbuf, sizeof(tmpbuf)-1, &ATTR( attrs, stripe_items), FALSE);
printf("%s\t%s\n", id->fullname, tmpbuf);
}
#endif
else
{
/* just display name */
if (id->fullname)
printf("%s\n", id->fullname);
else
printf(DFID"\n", PFID(&id->id));
}
}
void PostponeElement::enterElement(const Arabica::DOM::Element<std::string>& node) {
if (!_interpreter->getDataModel()) {
LOG(ERROR) << "Postpone element requires a datamodel";
return;
}
// under which condition will we postpone the current event?
if (HAS_ATTR(node, "cond")) {
std::string cond = ATTR(node, "cond");
try {
if (!_interpreter->getDataModel().evalAsBool(cond))
return;
} catch (Event e) {
LOG(ERROR) << "Syntax error in cond attribute of postpone element:" << std::endl << e << std::endl;
return;
}
}
// chaining causes the event to fire if the condition was true since postponing
bool chained = false;
if (HAS_ATTR(node, "chaining")) {
chained = iequals(ATTR(node, "chaining"), "true");
}
// when will we refire the event?
std::string until;
try {
if (HAS_ATTR(node, "untilexpr")) {
until = _interpreter->getDataModel().evalAsString(ATTR(node, "untilexpr"));
} else if (HAS_ATTR(node, "until")) {
until = ATTR(node, "until");
}
} catch (Event e) {
LOG(ERROR) << "Syntax error in postpone element untilexpr:" << std::endl << e << std::endl;
return;
}
if (until.length() == 0) {
LOG(ERROR) << "Postpone element requires until or untilexpr attribute ";
return;
}
// LOG(INFO) << until;
#if 0
std::string timeoutStr = "0s";
try {
if (HAS_ATTR(node, "timeoutexpr")) {
timeoutStr = _interpreter->getDataModel().evalAsString(ATTR(node, "timeoutexpr"));
} else if (HAS_ATTR(node, "timeout")) {
timeoutStr = ATTR(node, "timeout");
}
} catch (Event e) {
LOG(ERROR) << "Syntax error in postpone element timeoutexpr:" << std::endl << e << std::endl;
return;
}
uint64_t timeout = 0;
NumAttr timeoutAttr(timeoutStr);
if (iequals(timeoutAttr.unit, "s")) {
timeout = strTo<int>(timeoutAttr.value) * 1000;
} else if (iequals(timeoutAttr.unit, "ms")) {
timeout = strTo<int>(timeoutAttr.value);
}
if (timeout > 0) {
timeout += tthread::chrono::system_clock::now();
}
#endif
Event currEvent = _interpreter->getCurrentEvent();
Resubmitter::postpone(currEvent, until, 0, chained, _interpreter);
}
void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent, const std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths)
{
ENSURE(pParent);
int i;
// Our object we are going to create
IGUIObject *object = NULL;
XMBAttributeList attributes = Element.GetAttributes();
// Well first of all we need to determine the type
CStr type (attributes.GetNamedItem(pFile->GetAttributeID("type")));
if (type.empty())
type = "empty";
// Construct object from specified type
// henceforth, we need to do a rollback before aborting.
// i.e. releasing this object
object = ConstructObject(type);
if (!object)
{
// Report error that object was unsuccessfully loaded
LOGERROR(L"GUI: Unrecognized object type \"%hs\"", type.c_str());
return;
}
// Cache some IDs for element attribute names, to avoid string comparisons
#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
ELMT(object);
ELMT(action);
ELMT(repeat);
ATTR(style);
ATTR(type);
ATTR(name);
ATTR(hotkey);
ATTR(z);
ATTR(on);
ATTR(file);
//
// Read Style and set defaults
//
// If the setting "style" is set, try loading that setting.
//
// Always load default (if it's available) first!
//
CStr argStyle (attributes.GetNamedItem(attr_style));
if (m_Styles.count("default") == 1)
object->LoadStyle(*this, "default");
if (! argStyle.empty())
{
// additional check
if (m_Styles.count(argStyle) == 0)
{
LOGERROR(L"GUI: Trying to use style '%hs' that doesn't exist.", argStyle.c_str());
}
else object->LoadStyle(*this, argStyle);
}
//
// Read Attributes
//
bool NameSet = false;
bool ManuallySetZ = false; // if z has been manually set, this turn true
CStr hotkeyTag;
// Now we can iterate all attributes and store
for (i=0; i<attributes.Count; ++i)
{
XMBAttribute attr = attributes.Item(i);
// If value is "null", then it is equivalent as never being entered
if (CStr(attr.Value) == "null")
continue;
// Ignore "type" and "style", we've already checked it
if (attr.Name == attr_type || attr.Name == attr_style)
continue;
// Also the name needs some special attention
if (attr.Name == attr_name)
{
CStr name (attr.Value);
// Apply the requested substitutions
for (size_t j = 0; j < NameSubst.size(); ++j)
name.Replace(NameSubst[j].first, NameSubst[j].second);
object->SetName(name);
NameSet = true;
continue;
}
// Wire up the hotkey tag, if it has one
if (attr.Name == attr_hotkey)
hotkeyTag = attr.Value;
if (attr.Name == attr_z)
ManuallySetZ = true;
// Try setting the value
if (object->SetSetting(pFile->GetAttributeString(attr.Name), attr.Value.FromUTF8(), true) != PSRETURN_OK)
{
LOGERROR(L"GUI: (object: %hs) Can't set \"%hs\" to \"%ls\"", object->GetPresentableName().c_str(), pFile->GetAttributeString(attr.Name).c_str(), attr.Value.FromUTF8().c_str());
// This is not a fatal error
}
}
// Check if name isn't set, generate an internal name in that case.
if (!NameSet)
{
object->SetName("__internal(" + CStr::FromInt(m_InternalNameNumber) + ")");
++m_InternalNameNumber;
}
// Attempt to register the hotkey tag, if one was provided
if (! hotkeyTag.empty())
m_HotkeyObjects[hotkeyTag].push_back(object);
CStrW caption (Element.GetText().FromUTF8());
if (! caption.empty())
{
// Set the setting caption to this
object->SetSetting("caption", caption, true);
// There is no harm if the object didn't have a "caption"
}
//
// Read Children
//
// Iterate children
XMBElementList children = Element.GetChildNodes();
for (i=0; i<children.Count; ++i)
{
// Get node
XMBElement child = children.Item(i);
// Check what name the elements got
int element_name = child.GetNodeName();
if (element_name == elmt_object)
{
// Call this function on the child
Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths);
}
else if (element_name == elmt_action)
{
// Scripted <action> element
// Check for a 'file' parameter
CStrW filename (child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
CStr code;
// If there is a file, open it and use it as the code
if (! filename.empty())
{
Paths.insert(filename);
CVFSFile scriptfile;
if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
{
LOGERROR(L"Error opening GUI script action file '%ls'", filename.c_str());
throw PSERROR_GUI_JSOpenFailed();
}
code = scriptfile.DecodeUTF8(); // assume it's UTF-8
}
// Read the inline code (concatenating to the file code, if both are specified)
code += CStr(child.GetText());
CStr action = CStr(child.GetAttributes().GetNamedItem(attr_on));
// We need to set the GUI this object belongs to because RegisterScriptHandler requires an associated GUI.
object->SetGUI(this);
object->RegisterScriptHandler(action.LowerCase(), code, this);
}
else if (element_name == elmt_repeat)
{
Xeromyces_ReadRepeat(child, pFile, object, Paths);
}
else
{
// Try making the object read the tag.
if (!object->HandleAdditionalChildren(child, pFile))
{
LOGERROR(L"GUI: (object: %hs) Reading unknown children for its type", object->GetPresentableName().c_str());
}
}
}
//
// Check if Z wasn't manually set
//
if (!ManuallySetZ)
{
// Set it automatically to 10 plus its parents
bool absolute;
GUI<bool>::GetSetting(object, "absolute", absolute);
// If the object is absolute, we'll have to get the parent's Z buffered,
// and add to that!
if (absolute)
{
GUI<float>::SetSetting(object, "z", pParent->GetBufferedZ() + 10.f, true);
}
else
// If the object is relative, then we'll just store Z as "10"
{
GUI<float>::SetSetting(object, "z", 10.f, true);
}
}
//
// Input Child
//
try
{
if (pParent == m_BaseObject)
AddObject(object);
else
pParent->AddChild(object);
}
catch (PSERROR_GUI& e)
{
LOGERROR(L"GUI error: %hs", e.what());
}
}
static int recov_list(recov_type_e state)
{
struct lmgr_iterator_t *it;
int rc;
entry_id_t id;
attr_set_t attrs;
char buff[128];
recov_status_t st;
const char *status;
/* TODO iter opt */
it = ListMgr_RecovList(&lmgr, state);
if (it == NULL) {
fprintf(stderr, "ERROR: cannot get the list of entries\n");
return -1;
}
attrs.attr_mask = RECOV_ATTR_MASK;
printf("%-8s %-15s %-40s %s\n", "type", "state", "path", "size");
while (!terminate &&
((rc =
ListMgr_RecovGetNext(it, &id, &attrs, &st)) != DB_END_OF_LIST)) {
if (rc) {
fprintf(stderr, "ERROR %d getting entry from recovery table\n", rc);
ListMgr_CloseIterator(it);
return rc;
}
FormatFileSize(buff, 128, ATTR(&attrs, size));
switch (st) {
case RS_FILE_OK:
status = "done";
break;
case RS_FILE_DELTA:
status = "done_old_data";
break;
case RS_NON_FILE:
status = "done_non_file";
break;
case RS_FILE_EMPTY:
status = "done_empty";
break;
case RS_NOBACKUP:
status = "done_no_backup";
break;
case RS_ERROR:
status = "failed";
break;
case -1:
status = "todo";
break;
default:
status = "?";
}
printf("%-8s %-15s %-40s %s\n", ATTR(&attrs, type), status,
ATTR(&attrs, fullpath), buff);
/* reset mask */
attrs.attr_mask = RECOV_ATTR_MASK;
}
return 0;
}
/**
* Get the list of children of a given parent (or list of parents).
* \param parent_list [in] list of parents to get the child of
* \param parent_count [in] number of ids in parent list
* \param attr_mask [in] required attributes for children
* \param child_id_list [out] ptr to array of child ids
* \param child_attr_list [out] ptr to array of child attrs
* \param child_count [out] number of returned children
*/
int ListMgr_GetChild( lmgr_t * p_mgr, const lmgr_filter_t * p_filter,
const wagon_t * parent_list, unsigned int parent_count,
int attr_mask,
wagon_t ** child_id_list, attr_set_t ** child_attr_list,
unsigned int * child_count)
{
result_handle_t result;
char *curr;
int filter_main = 0;
int filter_annex = 0;
int main_attrs = 0;
int dnames_attrs = 0;
int annex_attrs = 0;
char query[4096];
char fieldlist_main[1024] = "";
char fieldlist_dnames[1024] = "";
char fieldlist_annex[1024] = "";
char filter_str_main[1024] = "";
char filter_str_annex[1024] = "";
char tmp[2048];
char *path = NULL;
int path_len;
char * pc;
int rc, i;
/* TODO: querying children from several parent cannot work, since
* we need to get the paths of the children. Or we could do a
* lookup into parent_list to find the right one. In the meantime,
* try not to mess up the code. */
if (parent_count != 1)
RBH_BUG("cannot get children for several parent simultaneously");
/* always request for name to build fullpath in wagon */
attr_mask |= ATTR_MASK_name;
/* request is always on the MAIN table (which contains [parent_id, id] relationship */
/* /!\ possible cases:
* - simplest: the fields of the filter and the attributes to be retrieved are in the MAIN table
* - harder: the fields of the filter and attributes are in a different table
*/
/* 1) location of filters */
if ( p_filter )
{
char dummy_str[1024];
unsigned int dummy_uint;
if (dir_filter(p_mgr, dummy_str, p_filter, &dummy_uint) != FILTERDIR_NONE)
{
DisplayLog( LVL_MAJOR, LISTMGR_TAG, "Directory filter not supported in %s()", __func__ );
return DB_NOT_SUPPORTED;
}
else if (func_filter(p_mgr, dummy_str, p_filter, T_MAIN, FALSE, FALSE))
{
DisplayLog( LVL_MAJOR, LISTMGR_TAG, "Function filter not supported in %s()", __func__ );
return DB_NOT_SUPPORTED;
}
/* There is always a filter on T_DNAMES, which is the parent condition.
* Look for optional filters:
*/
filter_main = filter2str( p_mgr, filter_str_main, p_filter, T_MAIN,
FALSE, TRUE );
if ( annex_table )
filter_annex = filter2str( p_mgr, filter_str_annex, p_filter,
T_ANNEX, FALSE, TRUE );
else
filter_annex = 0;
/* @TODO to be implemented */
#if 0
filter_stripe_info =
filter2str( p_mgr, filter_str_stripe_info, p_filter, T_STRIPE_INFO,
( filter_main > 0 ) || ( filter_annex > 0 ), TRUE );
filter_stripe_items =
filter2str( p_mgr, filter_str_stripe_items, p_filter, T_STRIPE_ITEMS,
( filter_main > 0 ) || ( filter_annex > 0 )
|| ( filter_stripe_info > 0 ), TRUE );
#endif
}
/* 2) location of requested attributes */
if (attr_mask)
{
/* retrieve source info for generated fields */
add_source_fields_for_gen( &attr_mask );
main_attrs = attrmask2fieldlist( fieldlist_main, attr_mask, T_MAIN,
/* leading comma */ TRUE, /* for update */ FALSE,
/* prefix */ MAIN_TABLE".", /* postfix */ "" );
dnames_attrs += attrmask2fieldlist( fieldlist_dnames, attr_mask, T_DNAMES,
/* leading comma */ TRUE, /* for update */ FALSE,
/* prefix */ DNAMES_TABLE".", /* postfix */ "" );
if ( annex_table )
annex_attrs = attrmask2fieldlist( fieldlist_annex, attr_mask, T_ANNEX,
/* leading comma */ TRUE, /* for update */ FALSE,
/* prefix */ ANNEX_TABLE".", /* postfix */ "" );
else
annex_attrs = 0;
}
else
{
/* no returned attrs */
if (child_attr_list)
*child_attr_list = NULL;
}
pc = parent_cond(p_mgr, tmp, sizeof(tmp), parent_list, parent_count, DNAMES_TABLE".");
if (!pc)
return DB_BUFFER_TOO_SMALL;
curr = query;
/* SELECT clause */
/* id + dname fields */
curr += sprintf(curr, "SELECT "DNAMES_TABLE".id%s", fieldlist_dnames);
/* main attrs */
if (main_attrs)
curr += sprintf(curr, "%s", fieldlist_main);
/* annex attrs */
if (annex_attrs)
curr += sprintf(curr, "%s", fieldlist_annex);
/* FROM clause */
curr += sprintf(curr, " FROM "DNAMES_TABLE);
if (main_attrs || filter_main)
curr += sprintf(curr, " LEFT JOIN "MAIN_TABLE
" ON "DNAMES_TABLE".id="MAIN_TABLE".id");
if (annex_attrs || filter_annex)
curr += sprintf(curr, " LEFT JOIN "ANNEX_TABLE
" ON "DNAMES_TABLE".id="ANNEX_TABLE".id");
/* WHERE clause */
curr += sprintf(curr, " WHERE %s", pc);
if (filter_main)
curr += sprintf(curr, " AND %s", filter_str_main);
if (filter_annex)
curr += sprintf(curr, " AND %s", filter_str_annex);
retry:
rc = db_exec_sql(&p_mgr->conn, query, &result);
if (lmgr_delayed_retry(p_mgr, rc))
goto retry;
else if (rc)
return rc;
/* copy result to output structures */
*child_count = db_result_nb_records(&p_mgr->conn, &result);
/* allocate entry_id array */
*child_id_list = MemCalloc(*child_count, sizeof(wagon_t));
if (*child_id_list == NULL)
return DB_NO_MEMORY;
if (child_attr_list)
{
*child_attr_list = MemCalloc(*child_count, sizeof(attr_set_t));
if (*child_attr_list == NULL)
{
rc = DB_NO_MEMORY;
goto array_free;
}
}
/* Allocate a string long enough to contain the parent path and a
* child name. */
path_len = strlen(parent_list[0].fullname) + RBH_NAME_MAX + 2;
path = malloc(path_len);
if (!path) {
DisplayLog( LVL_MAJOR, LISTMGR_TAG, "Can't alloc enough memory (%d bytes)",
path_len );
rc = DB_NO_MEMORY;
goto array_free;
}
for (i = 0; i < *child_count; i++)
{
char *res[128]; /* 128 fields per row is large enough */
rc = db_next_record(&p_mgr->conn, &result, res, 128);
if ( rc )
goto array_free;
/* copy id to array */
pk2entry_id(p_mgr, res[0], &((*child_id_list)[i].id));
/* copy attributes to array */
if (child_attr_list)
{
(*child_attr_list)[i].attr_mask = attr_mask;
/* first id, then dnames attrs, then main attrs, then annex attrs */
if (dnames_attrs)
{
/* shift of 1 for id */
rc = result2attrset( T_DNAMES, res + 1, dnames_attrs, &((*child_attr_list)[i]) );
if ( rc )
goto array_free;
}
if (main_attrs)
{
/* first id, then main attrs, then annex attrs */
/* shift of 1 for id */
rc = result2attrset( T_MAIN, res + dnames_attrs + 1, main_attrs, &((*child_attr_list)[i]) );
if ( rc )
goto array_free;
}
if (annex_attrs)
{
/* shift of main_attrs count */
rc = result2attrset( T_ANNEX, res + dnames_attrs + main_attrs + 1, annex_attrs,
&((*child_attr_list)[i]) );
if ( rc )
goto array_free;
}
#ifdef _LUSTRE
if (stripe_fields(attr_mask))
{
if (get_stripe_info( p_mgr, res[0], &ATTR(&(*child_attr_list)[i], stripe_info),
&ATTR(&(*child_attr_list)[i], stripe_items) ))
{
ATTR_MASK_UNSET(&(*child_attr_list)[i], stripe_info);
ATTR_MASK_UNSET(&(*child_attr_list)[i], stripe_items);
}
}
#endif
generate_fields(&((*child_attr_list)[i]));
/* Note: path is properly sized already to not overflow. */
sprintf(path, "%s/%s", parent_list[0].fullname,
(*child_attr_list)[i].attr_values.name);
(*child_id_list)[i].fullname = strdup(path);
}
}
if (path)
free(path);
db_result_free( &p_mgr->conn, &result );
return 0;
array_free:
if (path)
free(path);
if (child_attr_list && *child_attr_list)
{
MemFree(*child_attr_list);
*child_attr_list = NULL;
}
MemFree(*child_id_list);
*child_id_list = NULL;
return rc;
}