On Thu, Oct 16, 2008 at 07:47:50AM -0700, Jay Anderson wrote:
> I set up a single file that would fail, and ran robocopy. The robocopy
> command and output is listed below. The output from the dtrace script can be
> found at http://jayd.freeshell.org/sdwrite.txt. The unresolvable SIDs that
> cause the problem are:
>
> S-1-5-21-144191708-1373204103-1923745731-512
> S-1-5-21-144191708-1373204103-1923745731-513
>
> I don't see these SIDs listed in the dtrace script output.
How did you determine that these SIDs cause the problem? Also, just to
be sure, you are running with unresolvable SID mapping enabled, yes? :)
Try the attached DTrace script:
# ./idmap.d $(pgrep idmapd)
Nico
--
#!/usr/sbin/dtrace -ws
#pragma D option strsize=512
BEGIN {
self->once = 0;
self->db = "?";
}
/*
* RPCs
*
* TODO: add more decoding of RPC args/results.
*/
pid$1::idmap_null_1_svc:entry,
pid$1::idmap_null_1_svc:return,
pid$1::idmap_get_mapped_ids_1_svc:return,
pid$1::idmap_list_mappings_1_svc:entry,
pid$1::idmap_list_mappings_1_svc:return,
pid$1::idmap_list_namerules_1_svc:entry,
pid$1::idmap_list_namerules_1_svc:return,
pid$1::idmap_update_1_svc:entry,
pid$1::idmap_update_1_svc:return,
pid$1::idmap_get_prop_1_svc:entry,
pid$1::idmap_get_prop_1_svc:return,
pid$1::idmap_get_mapped_id_by_name_1_svc:entry,
pid$1::idmap_get_mapped_id_by_name_1_svc:return
{
trace(probename);
}
pid$1::lookup_name_cache:entry,
pid$1::lookup_cache_pid2sid:entry,
pid$1::lookup_cache_sid2pid:entry,
pid$1::update_cache_pid2sid:entry,
pid$1::update_cache_sid2pid:entry
{
self->db = "cache";
trace(probename);
}
pid$1::lookup_name_cache:return,
pid$1::lookup_cache_pid2sid:return,
pid$1::lookup_cache_sid2pid:return,
pid$1::update_cache_pid2sid:return,
pid$1::update_cache_sid2pid:return
{
self->db = "?";
trace(probename);
}
pid$1::sql_compile_n_step_once:entry
{
self->sql = arg1;
}
pid$1::sql_compile_n_step_once:return
/(int)arg1 == -9977/
{
printf("DB (%s) entry not found, SQL: %s\n", self->db,
copyinstr(self->sql));
}
pid$1::sql_compile_n_step_once:return
/arg1 != 0 && (int)arg1 != -9977/
{
printf("DB (%s) error (%d) executing SQL: %s\n", self->db,
(int)arg1, copyinstr(self->sql));
}
pid$1::sql_compile_n_step_once:return
/(signed int)arg1 == 0/
{
printf("DB (%s) entry found, SQL: %s\n", self->db,
copyinstr(self->sql));
}
pid$1::sql_exec_no_cb:entry
{
self->db1 = arg1;
self->sql = arg2;
}
pid$1::sql_exec_no_cb:return
/arg1 != 0/
{
printf("DB (%s) SQL exec failure (%d): %s\n",
copyinstr(self->db1), (int)arg1,
copyinstr(self->sql));
}
pid$1::sql_exec_no_cb:return
/arg1 == 0/
{
printf("DB (%s) SQL exec success: %s\n",
copyinstr(self->db1),
copyinstr(self->sql));
}
/*
* idmap_get_mapped_ids_1_svc()
*
* This is the main RPC, we really want the thread ID and count of
* requests.
*/
pid$1::idmap_get_mapped_ids_1_svc:entry
{
printf("idmap_get_mapped_id_by_name_1_svc() - batch with %d requests,
tid = %d\n",
arg0, tid);
}
/*
* First a bunch of probes for the first pass over an ID mapping
* request. The operations here are ones that are fast/local or can't
* be made asynchronous (e.g., getpwuid_r()).
*
* The sid2pid_first_pass:entry probes should be replaced with a single
* USDT probe.
*
* There's several of these because of the need to have conditional
* behavior.
*/
pid$1::sid2pid_first_pass:entry
{
self->statep = arg0;
self->req = arg1;
self->res = arg2;
self->req_flag = *(int *)copyin(self->req, 4);
self->req_direction = *(int *)copyin(self->req + 4, 4);
self->req_id1_idtype = *(int *)copyin(self->req + 8, 4);
self->req_id1_sid_prefixp = *(unsigned int *)copyin(self->req + 12, 4);
self->req_id1_sid_rid = *(unsigned int *)copyin(self->req + 16, 4);
self->req_id1domainp = *(unsigned int *)copyin(self->req + 20, 4);
self->req_id1namep = *(unsigned int *)copyin(self->req + 24, 4);
self->req_id1_sid_prefix = "";
self->req_id1domain = "";
self->req_id1name = "";
}
pid$1::sid2pid_first_pass:entry
/self->req_id1_sid_prefixp != 0/
{
self->req_id1_sid_prefix = copyinstr(self->req_id1_sid_prefixp);
}
pid$1::sid2pid_first_pass:entry
/self->req_id1domainp != 0/
{
self->req_id1domain = copyinstr(self->req_id1domainp);
}
pid$1::sid2pid_first_pass:entry
/self->req_id1namep != 0/
{
self->req_id1name = copyinstr(self->req_id1namep);
}
pid$1::sid2pid_first_pass:entry
{
printf("sid2pid_first_pass(%p, req->flag = %x, req->direction = %x,
req->id1.idtype = %d, req->id1.sid.prefix = %s, req->id1.sid.rid = %d,
req->id1domain = %s, req->id1name = %s, tid = %d\n",
self->statep, self->req_flag, self->req_direction,
self->req_id1_idtype, self->req_id1_sid_prefix,
self->req_id1_sid_rid, self->req_id1domain, self->req_id1name,
tid);
}
pid$1::sid2pid_first_pass:return
/arg1 == 0/
{
self->res_retcode = *(int *)copyin(self->res, 4);
self->res_id_idtype = *(int *)copyin(self->res + 4, 4);
self->res_id_pid = *(int *)copyin(self->res + 8, 4);
self->req_direction = *(int *)copyin(self->req + 4, 4);
printf("sid2pid_first_pass(...) -> retcode = %d, status flags = %x,
idtype = %d, id = %d, tid = %d\n",
self->res_retcode, self->req_direction, self->res_id_idtype,
self->res_id_pid, tid);
}
pid$1::sid2pid_first_pass:return
/arg1 != 0/
{
printf("sid2pid_first_pass(...) = %d, tid = %d\n",
(int)arg1, tid);
}
pid$1::sid2pid_first_pass:return
{
self->statep = 0;
}
/* Same thing for pid2sid_first_pass() */
pid$1::pid2sid_first_pass:entry
{
self->statep = arg0;
self->req = arg1;
self->res = arg2;
self->req_flag = *(int *)copyin(self->req, 4);
self->req_direction = *(int *)copyin(self->req + 4, 4);
self->req_id1_idtype = *(int *)copyin(self->req + 8, 4);
self->req_id1_pid = *(unsigned int *)copyin(self->req + 12, 4);
self->req_id1namep = *(unsigned int *)copyin(self->req + 24, 4);
self->req_id1name = "";
}
pid$1::pid2sid_first_pass:entry
/self->req_id1namep != 0/
{
self->req_id1name = copyinstr(self->req_id1namep);
}
pid$1::pid2sid_first_pass:entry
{
printf("pid2sid_first_pass(%p, req->flag = %x, req->direction = %x,
req->id1.idtype = %d, req->id1.pid = %d, req->id1name = %s, tid = %d\n",
self->statep, self->req_flag, self->req_direction,
self->req_id1_idtype, self->req_id1_pid,
self->req_id1name, tid);
}
/* pid2sid_first_pass() return could be much more verbose; see sid2pid above */
pid$1::pid2sid_first_pass:return
{
self->statep = 0;
}
/*
* Parts of the first pass
*
* Well-known mappings, local SID mappings and the cache are checked in
* the first pass.
*
* These functions are called from sid2pid_first_pass() and
* pid2sid_first_pass().
*/
/* Was this a well-known SID? */
pid$1::lookup_wksids_sid2pid:return
/arg1 == 0 && self->statep != 0/
{
printf("WELL-KNOWN SID: %s-%d, tid = %d\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid, tid);
}
pid$1::lookup_wksids_sid2pid:return
/(int)arg1 == -9977 && self->statep != 0/
{
printf("SID %s-%d NOT a well-known SID, tid = %d\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid, tid);
}
pid$1::lookup_wksids_sid2pid:return
/arg1 != 0 && (int)arg1 != -9977 && self->statep != 0/
{
printf("ERROR %d WHILE CHECKING WK MAPPING FOR SID %s-%d, tid = %d\n",
(int)arg1, self->req_id1_sid_prefix,
self->req_id1_sid_rid, tid);
}
pid$1::lookup_wksids_pid2sid:return
/arg1 == 0 && self->statep != 0/
{
printf("POSIX ID %d (type %d) MAPPED TO WELL-KNOWN SID, tid = %d\n",
self->req_id1_pid, self->req_id1_idtype, tid);
}
pid$1::lookup_wksids_pid2sid:return
/(int)arg1 == -9977 && self->statep != 0/
{
printf("POSIX ID %d (type %d) NOT mapped to well-known SID, tid = %d\n",
self->req_id1_pid, self->req_id1_idtype, tid);
}
pid$1::lookup_wksids_pid2sid:return
/arg1 != 0 && (int)arg1 != -9977 && self->statep != 0/
{
printf("ERROR %d WHILE CHECKING WK MAPPING FOR POSIX ID %d (type %d),
tid = %d\n",
(int)arg1, self->req_id1_pid, self->req_id1_idtype, tid);
}
/* Was this a local SID? */
pid$1::lookup_localsid2pid:return
/arg1 == 0 && self->statep != 0/
{
printf("LOCAL SID: %s-%d, tid = %d\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid, tid);
}
pid$1::lookup_localsid2pid:return
/(int)arg1 == -9977 && self->statep != 0/
{
printf("NOT A LOCAL SID: %s-%d, tid = %d\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid, tid);
}
pid$1::lookup_localsid2pid:return
/arg1 != 0 && (int)arg1 != -9977 && self->statep != 0/
{
printf("ERROR %d WHILE CHECKING LOCAL SID MAPPING FOR SID %s-%d, tid =
%d\n",
(int)arg1, self->req_id1_sid_prefix, self->req_id1_sid_rid,
tid);
}
/* Was a mapping for this SID cached? */
pid$1::lookup_cache_sid2pid:return
/arg1 == 0 && self->statep != 0/
{
printf("CACHED MAPPING: %s-%d, tid = %d\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid, tid);
}
pid$1::lookup_cache_sid2pid:return
/(int)arg1 == -9977 && self->statep != 0/
{
printf("CACHED MISS WHILE LOOKING FOR SID %s-%d, tid = %d\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid, tid);
}
pid$1::lookup_cache_sid2pid:return
/arg1 != 0 && (int)arg1 != -9977 && self->statep != 0/
{
printf("ERROR %d WHILE CHECKING CACHE FOR SID %s-%d, tid = %d\n",
(int)arg1, self->req_id1_sid_prefix,
self->req_id1_sid_rid, tid);
}
pid$1::lookup_cache_pid2sid:return
/arg1 == 0 && self->statep != 0/
{
printf("CACHED MAPPING FOR POSIX ID %d (type %d), tid = %d\n",
self->req_id1_pid, self->req_id1_idtype, tid);
}
pid$1::lookup_cache_pid2sid:return
/(int)arg1 == -9977 && self->statep != 0 && self->req_id1_pid >= 2147483648/
{
printf("NO MAPPING FOUND FOR EPHEMERAL POSIX ID %d (type %d), tid =
%d\n",
self->req_id1_pid, self->req_id1_idtype, tid);
}
pid$1::lookup_cache_pid2sid:return
/(int)arg1 == -9977 && self->statep != 0 && self->req_id1_pid < 2147483648/
{
printf("NO MAPPING FOUND FOR POSIX ID %d (type %d), tid = %d\n",
self->req_id1_pid, self->req_id1_idtype, tid);
}
pid$1::lookup_cache_pid2sid:return
/arg1 != 0 && (int)arg1 == -9977 && self->statep != 0/
{
printf("ERROR %d WHILE CHECKING CACHE FOR POSIX ID %d (type %d), tid =
%d\n",
(int)arg1, self->req_id1_pid, self->req_id1_idtype,
tid);
}
/* Was this SID mapped to a local SID? */
pid$1::generate_localsid:entry
{
self->gl_req = arg0;
self->gl_res = arg1;
printf("MAPPING NON-EPHEMERAL POSIX ID %d (type %d) TO LOCAL SID...
(fallback = %d), tid = %d\n",
self->req_id1_pid, self->req_id1_idtype, arg2, tid);
}
pid$1::generate_localsid:return
{
self->gl_req_id1_idtype = *(int *)copyin(self->gl_req + 8, 4);
self->gl_req_id1_pid = *(unsigned int *)copyin(self->gl_req + 12, 4);
}
pid$1::generate_localsid:return
/arg1 != 0/
{
printf("generate_localsid(%d (type %d)) = %d, tid = %d\n",
self->gl_req_id1_pid, self->gl_req_id1_idtype,
(int)arg1, tid);
}
pid$1::generate_localsid:return
/arg1 == 0/
{
self->gl_res_id1_idtype = *(int *)copyin(self->gl_res + 4, 4);
self->gl_res_id1_sid_prefix = copyinstr((uintptr_t)*(unsigned int
*)copyin(self->gl_res + 8, 4));
self->gl_res_id1_sid_rid = *(unsigned int *)copyin(self->gl_res + 12,
4);
printf("generate_localsid(%d (type %d)) = %d -> %s-%d (type %d), tid =
%d\n",
self->gl_req_id1_pid, self->gl_req_id1_idtype, (int)arg1,
self->gl_res_id1_sid_prefix, self->gl_res_id1_sid_rid,
self->gl_res_id1_idtype, tid);
}
/* Was this SID mapped to an ephemeral ID? */
pid$1::dynamic_ephemeral_mapping:entry
{
self->eph_req = arg1;
self->eph_res = arg2;
self->eph_req_id1_idtype = *(int *)copyin(self->eph_req + 8, 4);
self->eph_req_id1_sid_prefix = copyinstr((uintptr_t)*(unsigned int
*)copyin(self->eph_req + 12, 4));
self->eph_req_id1_sid_rid = *(unsigned int *)copyin(self->eph_req + 16,
4);
}
pid$1::dynamic_ephemeral_mapping:return
/arg1 == 0/
{
self->eph_res_retcode = *(int *)copyin(self->eph_req, 4);
self->eph_res_id_idtype = *(int *)copyin(self->eph_req + 4, 4);
self->eph_res_id_pid = *(int *)copyin(self->eph_req + 8, 4);
printf("dynamic_ephemeral_mapping(%s-%d) = %d -> %d (type %d), tid =
%d\n",
self->eph_req_id1_sid_prefix, self->eph_req_id1_sid_rid,
self->eph_res_retcode, self->eph_res_id_pid,
self->eph_res_id_idtype, tid);
}
pid$1::dynamic_ephemeral_mapping:return
/arg1 != 0/
{
self->eph_res_retcode = *(int *)copyin(self->eph_req, 4);
printf("dynamic_ephemeral_mapping(%s-%d) = %d (retcode %d), tid = %d\n",
self->eph_req_id1_sid_prefix, self->eph_req_id1_sid_rid,
(int)arg1, self->eph_res_retcode, tid);
}
/* Was the result of an LDAP lookup for this SID cached? */
pid$1::lookup_name_cache:return
/arg1 == 0 && self->statep != 0/
{
printf("NAME CACHE HIT: %s-%d, tid = %d\n", self->req_id1_sid_prefix,
self->req_id1_sid_rid, tid);
}
/* adutils tracing */
/* Start of SID->name AD lookup */
pid$1::idmap_sid2name_batch_add1:entry
{
self->sidprefix = copyinstr(arg1);
self->rid = *(unsigned int *)copyin(arg2, 4);
printf("idmap_sid2name_batch_add1(%s-%d), tid = %d\n", self->sidprefix,
self->rid, tid);
}
/* This is NOT the end of the SID->name AD lookup */
pid$1::idmap_sid2name_batch_add1:return
{
printf("idmap_sid2name_batch_add1(%s-%d) = %d, tid = %d\n",
self->sidprefix, self->rid, (int)arg1, tid);
}
/* Start of name->SID AD lookup */
pid$1::idmap_name2sid_batch_add1:entry
{
self->name = copyinstr(arg1);
self->domain = copyinstr(arg2);
printf("idmap_name2sid_batch_add1([EMAIL PROTECTED]), tid = %d\n",
self->name, self->domain, tid);
}
/* This is NOT the end of the name->SID AD lookup */
pid$1::idmap_name2sid_batch_add1:return
{
printf("idmap_name2sid_batch_add1([EMAIL PROTECTED]) = %d, tid = %d\n",
self->name, self->domain, (int)arg1, tid);
}
pid$1::idmap_lookup_batch_end:entry
{
printf("Waiting for AD lookups to finish, tid = %d\n", tid);
self->trace_batch_end = 0;
}
pid$1::idmap_lookup_batch_end:return
{
printf("idmap_lookup_batch_end() = %d, tid = %d\n",
(int)arg1, tid);
self->trace_batch_end = 1;
}
pid$1::idmap_lookup_release_batch:entry
/self->trace_batch_end != 0/
{
printf("AD lookup batch abandoned, tid = %d\n", tid);
}
/*
* We can't access arg10 in DTrace... So we root around in arious structs
* to get at what we need:
*
* - the pointer to idmap_q_t struct for this LDAP search
* - the pointer to msgid field of that idmap_q_t struct
* - the pointer to rc field of that idmap_q_t struct
*/
pid$1::idmap_batch_add1:entry
{
self->batch = arg0;
self->lastsent = *(unsigned int *)copyin(self->batch + 28, 4);
self->qp = self->batch + 60 + (60 * self->lastsent);
self->msgidp = self->qp + 52;
self->rcpp = self->qp + 48;
}
pid$1::ldap_search_ext:entry
{
self->filter = copyinstr(arg3);
}
pid$1::ldap_search_ext:return
{
self->msgid = *(unsigned int *)copyin(self->msgidp, 4);
printf("ldap_search_ext(%s) = %d -> msgid = %d, tid = %d\n",
self->filter, (int)arg1, self->msgid, tid);
}
pid$1::ldap_result:return
{
self->ldap_result_rc = arg1;
printf("ldap_result() = %d, tid = %d\n", (int)arg1, tid);
}
pid$1::idmap_batch_add1:return
{
self->rcp = *(unsigned int *)copyin(self->rcpp, 4);
printf("idmap_batch_add1(...) = %d, msgid = %d, tid = %d\n",
(int)arg1, self->msgid, tid);
}
pid$1::ldap_msgid:return
{
printf("ldap_msgid() = %d, tid = %d\n", arg1, tid);
}
/* A result entry came back */
pid$1::idmap_quesearchresbymsgid:entry
{
self->found_msgid = arg1;
printf("DS returned an LDAP result entry for msgid #%d, tid = %d\n",
arg1, tid);
}
pid$1::idmap_quesearchresbymsgid:return
{
printf("idmap_quesearchresbymsgid(%d) = %d, tid = %d\n",
self->found_msgid, arg1, tid);
}
/* No more result entries are coming back for some msgid */
pid$1::idmap_msgid2query:entry
{
self->found_msgid = arg1;
printf("DS LDAP results for msgid #%d DONE, tid = %d\n",
arg1, tid);
}
/* We probably don't need to trace the idmap_bv_*() functions... */
pid$1::idmap_bv_objsid2sidstr:entry
{
self->obj_res_ridp = arg1;
}
pid$1::idmap_bv_objsid2sidstr:return
/arg1 != 0/
{
self->obj_sidprefix = copyinstr(arg1);
self->obj_rid = *(unsigned int *)copyin(self->obj_res_ridp, 4);
printf("Found SID %s-%d for LDAP search msgid #%d, tid = %d\n",
copyinstr(arg1), *(unsigned int *)copyin(self->obj_res_ridp, 4),
self->found_msgid, tid);
}
pid$1::idmap_bv_objsid2sidstr:return
/arg1 == 0/
{
printf("PARSE ERROR: objectSid attribute for LDAP search result entry
msgid #%d, tid = %d\n",
self->found_msgid, tid);
}
/* Set results for some search */
pid$1::idmap_setqresults:entry
{
self->qres_ecnamep = *(unsigned int *)copyin(arg0, 4);
self->qres_edomainp = *(unsigned int *)copyin(arg0 + 4, 4);
self->qres_eunixtype = *(unsigned int *)copyin(arg0 + 8, 4);
self->qres_ecname = "";
self->qres_edomain = "";
self->qres_san = "";
self->qres_sid = "";
self->qres_rid = (unsigned int)arg5;
self->qres_sidtype = (unsigned int)arg6;
self->qres_rcp = *(unsigned int *)copyin(arg0 + 48, 4);
}
pid$1::idmap_setqresults:entry
/self->qres_ecnamep/
{
self->qres_ecname = copyinstr(self->qres_ecnamep);
}
pid$1::idmap_setqresults:entry
/self->qres_edomainp/
{
self->qres_edomain = copyinstr(self->qres_edomainp);
}
pid$1::idmap_setqresults:entry
/arg1 != 0/
{
self->qres_san = copyinstr(arg1);
}
pid$1::idmap_setqresults:entry
/arg4 != 0/
{
self->qres_sid = copyinstr(arg4);
}
pid$1::dn2dns:return
/arg1 != 0 && self->qres_san != 0/
{
self->qres_dom = copyinstr(arg1);
}
pid$1::idmap_setqresults:return
{
self->qres_rc = *(int *)copyin(self->qres_rcp, 4);
printf("Results for LDAP search msgid #%d: rc = %d, expected_canon_name
= %s, expected_domain = %s, sid = %s-%d, canon_name (san) = %s, dom = %s,
sid_type = %d, tid = %d\n",
self->found_msgid, self->qres_rc, self->qres_ecname,
self->qres_edomain, self->qres_sid, self->qres_rid,
self->qres_san, self->qres_dom, self->qres_sidtype, tid);
}
/* Parse a result entry */
pid$1::idmap_get_adobject_batch:return
/self->found_msgid != 0 && self->qres_rc != 0/
{
printf("Result code for LDAP search msgid #%d: %d, tid = %d\n",
self->found_msgid, self->qres_rc, tid);
}
/* Now back to dbutils.c with the *_second_pass() functions */
pid$1::sid2pid_second_pass:entry
{
self->statep = arg0;
self->unres_mapping = *(unsigned int *)copyin(arg0 + 16, 4);
self->req = arg1;
self->res = arg2;
self->res_retcode = *(int *)copyin(self->res, 4);
self->req_flag = *(int *)copyin(self->req, 4);
self->req_direction = *(int *)copyin(self->req + 4, 4);
self->req_id1_idtype = *(int *)copyin(self->req + 8, 4);
self->req_id1_pid = *(unsigned int *)copyin(self->req + 12, 4);
self->req_id1_sid_prefixp = *(unsigned int *)copyin(self->req + 12, 4);
self->req_id1_sid_prefix = copyinstr(self->req_id1_sid_prefixp);
self->req_id1_sid_rid = *(unsigned int *)copyin(self->req + 16, 4);
self->req_id1domainp = *(unsigned int *)copyin(self->req + 20, 4);
self->req_id1domain = copyinstr(self->req_id1domainp);
self->req_id1namep = *(unsigned int *)copyin(self->req + 24, 4);
self->req_id1name = copyinstr(self->req_id1namep);
/*self->req_id1_sid_prefix = "";*/
/*self->req_id1domain = "";*/
/*self->req_id1name = "";*/
}
pid$1::sid2pid_second_pass:entry
/self->res_retcode != 0 && self->unres_mapping != 0 &&
self->req_id1_sid_prefix != "" && self->req_id1name == ""/
{
this->req_id1_idtypep = (int *)copyin(self->req + 8, 4);
*this->req_id1_idtypep = 4;
printf("Forcing req->id1.idtype == IDMAP_USID for unresolvable SID
%s-%u\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid);
copyout(this->req_id1_idtypep, self->req + 8, 4);
}
pid$1::sid2pid_second_pass:entry
/self->once == 0/
{
printf("unresolvable_sid_mapping == %d\n", self->unres_mapping);
self->once = 1;
}
pid$1::sid2pid_second_pass:entry
/self->req_id1_sid_prefixp != 0/
{
self->req_id1_sid_prefix = copyinstr(self->req_id1_sid_prefixp);
}
pid$1::sid2pid_second_pass:entry
/self->req_id1domainp != 0/
{
self->req_id1domain = copyinstr(self->req_id1domainp);
}
pid$1::sid2pid_second_pass:entry
/self->req_id1namep != 0/
{
self->req_id1name = copyinstr(self->req_id1namep);
}
pid$1::sid2pid_second_pass:entry
{
printf("sid2pid_second_pass(%p, req->flag = %x, req->direction = %x,
req->id1.idtype = %d, req->id1.sid.prefix = %s, req->id1.sid.rid = %d,
req->id1domain = %s, req->id1name = %s, tid = %d\n",
self->statep, self->req_flag, self->req_direction,
self->req_id1_idtype, self->req_id1_sid_prefix,
self->req_id1_sid_rid, self->req_id1domain,
self->req_id1name, tid);
self->statep = 0;
}
pid$1::sid2pid_second_pass:return
{
self->statep = 0;
}
pid$1::pid2sid_second_pass:entry
/self->req_id1namep != 0/
{
self->req_id1name = copyinstr(self->req_id1namep);
}
pid$1::pid2sid_second_pass:entry
{
printf("pid2sid_second_pass(%p, req->flag = %x, req->direction = %x,
req->id1.idtype = %d, req->id1.pid = %d, req->id1name = %s, tid = %d\n",
self->statep, self->req_flag, self->req_direction,
self->req_id1_idtype, self->req_id1_pid,
self->req_id1name, tid);
}
pid$1::pid2sid_second_pass:return
/arg1 == 0/
{
self->res_retcode = *(int *)copyin(self->res, 4);
self->res_id_idtype = *(int *)copyin(self->res + 4, 4);
self->res_id_pid = *(int *)copyin(self->res + 8, 4);
printf("sid2pid_first_pass(...) = 0 -> retcode = %d, idtype = %d, id =
%d, tid = %d\n",
self->res_retcode, self->res_id_idtype, self->res_id_pid, tid);
}
pid$1::pid2sid_second_pass:return
/arg1 != 0/
{
printf("sid2pid_first_pass(...) = %d, tid = %d\n",
(int)arg1, tid);
}
pid$1::pid2sid_second_pass:return
{
self->statep = 0;
}
/* Name-based mapping. TODO: this needs a lot more tracing! */
pid$1::name_based_mapping_sid2pid:return
{
printf("name_based_mapping_sid2pid(%s-%d) = %d, tid = %d\n",
self->req_id1_sid_prefix, self->req_id1_sid_rid,
(int)arg1, tid);
}
/* TODO: DS-based mapping */
/* TODO: SQLite2 tracing */
_______________________________________________
cifs-discuss mailing list
[email protected]
http://mail.opensolaris.org/mailman/listinfo/cifs-discuss
