not a long long like on 32-bit systems. From Evan Felix, PNL.
if (lock->l_resource == NULL) \
CDEBUG(D_DLMTRACE, "### " format \
" (UNKNOWN: lock %p(rc=%d/%d,%d) mode %s/%s on " \
- "res \?\? (rc=\?\?) type \?\?\? remote %Lx)\n" , \
+ "res \?\? (rc=\?\?) type \?\?\? remote "LPX64")\n" , \
## a, lock, lock->l_refc, lock->l_readers, \
lock->l_writers, \
ldlm_lockname[lock->l_granted_mode], \
else \
CDEBUG(D_DLMTRACE, "### " format \
" (%s: lock %p(rc=%d/%d,%d) mode %s/%s on res " \
- "%Lu (rc=%d) type %s remote %Lx)\n" , ## a, \
+ LPU64" (rc=%d) type %s remote "LPX64")\n" , ## a, \
lock->l_resource->lr_namespace->ns_name, lock, \
lock->l_refc, lock->l_readers, lock->l_writers, \
ldlm_lockname[lock->l_granted_mode], \
CDEBUG(D_OTHER, " -- Lock dump: %p (%s)\n", lock, ver);
if (lock->l_export && lock->l_export->exp_connection)
- CDEBUG(D_OTHER, " Node: NID %x (rhandle: %Lx)\n",
+ CDEBUG(D_OTHER, " Node: NID %x (rhandle: "LPX64")\n",
lock->l_export->exp_connection->c_peer.peer_nid,
lock->l_remote_handle.addr);
else
CDEBUG(D_OTHER, " Node: local\n");
CDEBUG(D_OTHER, " Parent: %p\n", lock->l_parent);
- CDEBUG(D_OTHER, " Resource: %p (%Ld)\n", lock->l_resource,
+ CDEBUG(D_OTHER, " Resource: %p ("LPD64")\n", lock->l_resource,
lock->l_resource->lr_name[0]);
CDEBUG(D_OTHER, " Requested mode: %d, granted mode: %d\n",
(int)lock->l_req_mode, (int)lock->l_granted_mode);
lock = ldlm_handle2lock(&dlm_req->lock_handle1);
if (!lock) {
- CERROR("blocking callback on lock %Lx - lock disappeared\n",
+ CERROR("blocking callback on lock "LPX64" - lock disappeared\n",
dlm_req->lock_handle1.addr);
RETURN(0);
}
lock = ldlm_handle2lock(&dlm_req->lock_handle1);
if (!lock) {
- CERROR("completion callback on lock %Lx - lock disappeared\n",
+ CERROR("completion callback on lock "LPX64" - lock disappeared\n",
dlm_req->lock_handle1.addr);
RETURN(0);
}
ENTRY;
ASSERT_KERNEL_CTXT("kernel doing mkdir outside kernel context\n");
- CDEBUG(D_INODE, "creating directory %*s\n", strlen(name), name);
+ CDEBUG(D_INODE, "creating directory %*s\n", (int)strlen(name), name);
down(&dir->d_inode->i_sem);
dchild = lookup_one_len(name, dir, strlen(name));
if (IS_ERR(dchild))
extent.start = *ppos;
extent.end = *ppos + count;
- CDEBUG(D_INFO, "Locking inode %ld, start %Lu end %Lu\n",
+ CDEBUG(D_INFO, "Locking inode %ld, start "LPU64" end "LPU64"\n",
inode->i_ino, extent.start, extent.end);
err = obd_enqueue(&sbi->ll_osc_conn, md, NULL, LDLM_EXTENT,
GOTO(out_eof, retval = -ENOMEM);
extent.start = *ppos;
extent.end = *ppos + count;
- CDEBUG(D_INFO, "Locking inode %ld, start %Lu end %Lu\n",
+ CDEBUG(D_INFO, "Locking inode %ld, start "LPU64" end "LPU64"\n",
inode->i_ino, extent.start, extent.end);
err = obd_enqueue(&sbi->ll_osc_conn, md, NULL, LDLM_EXTENT,
err = obd_destroy(ll_i2obdconn(inode), oa, md);
obdo_free(oa);
- CDEBUG(D_SUPER, "obd destroy of %Ld error %d\n",
+ CDEBUG(D_SUPER, "obd destroy of "LPD64" error %d\n",
md->lmd_object_id, err);
}
out:
tmp.o_id = md->lmd_oinfo[i].loi_id;
rc = obd_destroy(&lov->tgts[i].conn, &tmp, NULL);
if (rc)
- CERROR("Error destroying object %Ld on %d\n",
+ CERROR("Error destroying object "LPD64"on %d\n",
md->lmd_oinfo[i].loi_id, i);
}
RETURN(rc);
err = obd_getattr(&lov->tgts[i].conn, &tmp, NULL);
if (err) {
- CERROR("Error getattr object %Ld on %d: err = %d\n",
+ CERROR("Error getattr object "LPD64" on %d: err = %d\n",
md->lmd_oinfo[i].loi_id, i, err);
if (!rc)
rc = err;
rc = obd_setattr(&lov->tgts[i].conn, &tmp, NULL);
if (rc)
- CERROR("Error setattr object %Ld on %d\n",
+ CERROR("Error setattr object "LPD64" on %d\n",
tmp.o_id, i);
}
RETURN(rc);
rc = obd_open(&lov->tgts[i].conn, &tmp, NULL);
if (rc) {
rc2 = rc;
- CERROR("Error open object %Ld on %d\n",
+ CERROR("Error open object "LPD64" on %d\n",
md->lmd_oinfo[i].loi_id, i);
}
}
rc = obd_close(&lov->tgts[i].conn, &tmp, NULL);
if (rc)
- CERROR("Error close object %Ld on %d\n",
+ CERROR("Error close object "LPD64" on %d\n",
md->lmd_oinfo[i].loi_id, i);
}
RETURN(rc);
rc = obd_punch(&lov->tgts[i].conn, &tmp, NULL,
starti, endi);
if (rc)
- CERROR("Error punch object %Ld on %d\n",
+ CERROR("Error punch object "LPD64" on %d\n",
md->lmd_oinfo[i].loi_id, i);
}
RETURN(rc);
flags, cb, data, datalen, &(lockhs[i]));
// XXX add a lock debug statement here
if (rc)
- CERROR("Error obd_enqueue object %Ld subobj %Ld\n",
+ CERROR("Error obd_enqueue object "LPD64
+ " subobj "LPD64"\n",
md->lmd_object_id, md->lmd_oinfo[i].loi_id);
}
RETURN(rc);
submd.lmd_easize = sizeof(struct lov_mds_md);
rc = obd_cancel(&lov->tgts[i].conn, &submd, mode, &lockhs[i]);
if (rc)
- CERROR("Error cancel object %Ld subobj %Ld\n",
+ CERROR("Error cancel object "LPD64" subobj "LPD64"\n",
md->lmd_object_id, md->lmd_oinfo[i].loi_id);
}
RETURN(rc);
rc = ldlm_lock_match(obd->obd_namespace, res_id, LDLM_PLAIN,
NULL, 0, lock_mode, &lockh);
if (rc == 0) {
- LDLM_DEBUG_NOLOCK("enqueue res %Lu", res_id[0]);
+ LDLM_DEBUG_NOLOCK("enqueue res "LPU64, res_id[0]);
rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
res_id, LDLM_PLAIN, NULL, 0, lock_mode,
&flags, ldlm_completion_ast,
fd = list_entry(tmp, struct mds_file_data, mfd_list);
if (body->extra == fd->mfd_clientfd &&
body->fid1.id == fd->mfd_file->f_dentry->d_inode->i_ino) {
- CERROR("Re opening %Ld\n", body->fid1.id);
+ CERROR("Re opening "LPD64"\n", body->fid1.id);
RETURN(0);
}
}
{
struct mds_cb_data *mcb = (struct mds_cb_data *)jcb;
- CDEBUG(D_EXT2, "got callback for last_rcvd %Ld: rc = %d\n",
+ CDEBUG(D_EXT2, "got callback for last_rcvd "LPD64": rc = %d\n",
mcb->cb_last_rcvd, error);
if (!error && mcb->cb_last_rcvd > mcb->cb_mds->mds_last_committed)
mcb->cb_mds->mds_last_committed = mcb->cb_last_rcvd;
mds_fs_set_last_rcvd(mds, handle);
rc = lustre_fwrite(mds->mds_rcvd_filp, (char *)mcd, sizeof(*mcd), &off);
- CDEBUG(D_INODE, "wrote trans #%Ld for client '%s' at #%d: rc = %d\n",
+ CDEBUG(D_INODE, "wrote trans #"LPD64" for client '%s' at #%d: rc = %d\n",
last_rcvd, mcd->mcd_uuid, med->med_off, rc);
if (rc == sizeof(*mcd))
rc = ldlm_lock_match(obd->obd_namespace, res_id, LDLM_PLAIN,
NULL, 0, lock_mode, &srclockh);
if (rc == 0) {
- LDLM_DEBUG_NOLOCK("enqueue res %Lu", res_id[0]);
+ LDLM_DEBUG_NOLOCK("enqueue res "LPU64, res_id[0]);
rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
res_id, LDLM_PLAIN, NULL, 0, lock_mode,
&flags, ldlm_completion_ast,
rc = ldlm_lock_match(obd->obd_namespace, res_id, LDLM_PLAIN,
NULL, 0, lock_mode, &tgtlockh);
if (rc == 0) {
- LDLM_DEBUG_NOLOCK("enqueue res %Lu", res_id[0]);
+ LDLM_DEBUG_NOLOCK("enqueue res "LPU64, res_id[0]);
rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
res_id, LDLM_PLAIN, NULL, 0, lock_mode,
&flags, ldlm_completion_ast,
/* Take an exclusive lock on the resource that we're
* about to free, to force everyone to drop their
* locks. */
- LDLM_DEBUG_NOLOCK("getting EX lock res %Lu", res_id[0]);
+ LDLM_DEBUG_NOLOCK("getting EX lock res "LPU64, res_id[0]);
rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
res_id, LDLM_PLAIN, NULL, 0, LCK_EX,
&flags, ldlm_completion_ast,
mds_blocking_ast, NULL, 0, &oldhandle);
if (rc)
- CERROR("failed to get child inode lock (child ino %Ld, "
+ CERROR("failed to get child inode lock (child ino "LPD64", "
"dir ino %ld)\n",
res_id[0], de_old->d_inode->i_ino);
}
rc = ldlm_cli_cancel(&oldhandle);
if (rc < 0)
CERROR("failed to cancel child inode lock ino "
- "%Ld: %d\n", res_id[0], rc);
+ LPD64": %d\n", res_id[0], rc);
}
out_rename_tgtdir:
double_up(&de_srcdir->d_inode->i_sem, &de_tgtdir->d_inode->i_sem);
err = obd_connect(&conn, obd, cluuid);
- CDEBUG(D_IOCTL, "assigned export %Lx\n", conn.addr);
+ CDEBUG(D_IOCTL, "assigned export "LPX64"\n", conn.addr);
obd_conn2data(data, &conn);
if (err)
GOTO(out, err);
int dump_ioo(struct obd_ioobj *ioo)
{
- CERROR("obd_ioobj: ioo_id=%Ld, ioo_gr=%Ld, ioo_type=%d, ioo_bufct=%d\n",
+ CERROR("obd_ioobj: ioo_id="LPD64", ioo_gr="LPD64", ioo_type=%d, ioo_bufct=%d\n",
ioo->ioo_id, ioo->ioo_gr, ioo->ioo_type, ioo->ioo_bufcnt);
return -EINVAL;
}
int dump_lniobuf(struct niobuf_local *nb)
{
- CERROR("niobuf_local: addr=%p, offset=%Ld, len=%d, xid=%d, page=%p\n",
+ CERROR("niobuf_local: addr=%p, offset="LPD64", len=%d, xid=%d, page=%p\n",
nb->addr, nb->offset, nb->len, nb->xid, nb->page);
CERROR("nb->page: index = %ld\n", nb->page ? nb->page->index : -1);
int dump_rniobuf(struct niobuf_remote *nb)
{
- CERROR("niobuf_remote: offset=%Ld, len=%d, flags=%x, xid=%d\n",
+ CERROR("niobuf_remote: offset="LPD64", len=%d, flags=%x, xid=%d\n",
nb->offset, nb->len, nb->flags, nb->xid);
return -EINVAL;
{
CERROR("obdo: o_valid = %08x\n", oa->o_valid);
if (oa->o_valid & OBD_MD_FLID)
- CERROR("obdo: o_id = %Ld\n", oa->o_id);
+ CERROR("obdo: o_id = "LPD64"\n", oa->o_id);
if (oa->o_valid & OBD_MD_FLATIME)
- CERROR("obdo: o_atime = %Ld\n", oa->o_atime);
+ CERROR("obdo: o_atime = "LPD64"\n", oa->o_atime);
if (oa->o_valid & OBD_MD_FLMTIME)
- CERROR("obdo: o_mtime = %Ld\n", oa->o_mtime);
+ CERROR("obdo: o_mtime = "LPD64"\n", oa->o_mtime);
if (oa->o_valid & OBD_MD_FLCTIME)
- CERROR("obdo: o_ctime = %Ld\n", oa->o_ctime);
+ CERROR("obdo: o_ctime = "LPD64"\n", oa->o_ctime);
if (oa->o_valid & OBD_MD_FLSIZE)
- CERROR("obdo: o_size = %Ld\n", oa->o_size);
+ CERROR("obdo: o_size = "LPD64"\n", oa->o_size);
if (oa->o_valid & OBD_MD_FLBLOCKS) /* allocation of space */
- CERROR("obdo: o_blocks = %Ld\n", oa->o_blocks);
+ CERROR("obdo: o_blocks = "LPD64"\n", oa->o_blocks);
if (oa->o_valid & OBD_MD_FLBLKSZ)
CERROR("obdo: o_blksize = %d\n", oa->o_blksize);
if (oa->o_valid & OBD_MD_FLMODE)
RETURN(NULL);
}
- CDEBUG(D_IOCTL, "looking for export addr %Lx cookie %Lx\n",
+ CDEBUG(D_IOCTL, "looking for export addr "LPX64" cookie "LPX64"\n",
conn->addr, conn->cookie);
export = (struct obd_export *) (unsigned long)conn->addr;
if (!kmem_cache_validate(export_cachep, (void *)export))
if (!(export = class_conn2export(conn))) {
fixme();
CDEBUG(D_IOCTL, "disconnect: attempting to free "
- "nonexistent client %Lx\n", conn->addr);
+ "nonexistent client "LPX64"\n", conn->addr);
RETURN(-EINVAL);
}
ENTRY;
if (!class_conn2export(conn)) {
- CDEBUG(D_IOCTL, "fatal: invalid client %Lx\n", conn->addr);
+ CDEBUG(D_IOCTL, "fatal: invalid client "LPX64"\n", conn->addr);
RETURN(-EINVAL);
}
export = class_conn2export(conn);
if (!export) {
- CDEBUG(D_IOCTL, "fatal: invalid client %Lx\n", conn->addr);
+ CDEBUG(D_IOCTL, "fatal: invalid client "LPX64"\n", conn->addr);
RETURN(-EINVAL);
}
obd = class_conn2obd(conn);
if (!obd) {
- CDEBUG(D_IOCTL, "fatal: invalid client %Lx\n", conn->addr);
+ CDEBUG(D_IOCTL, "fatal: invalid client "LPX64"\n", conn->addr);
RETURN(-EINVAL);
}
ENTRY;
if (!obd) {
- CERROR("invalid client %Lx\n", conn->addr);
+ CERROR("invalid client "LPX64"\n", conn->addr);
return -EINVAL;
}
obd = class_conn2obd(conn);
if (!obd) {
- CERROR("invalid client %Lx\n", conn->addr);
+ CERROR("invalid client "LPX64"\n", conn->addr);
RETURN(-EINVAL);
}
- CDEBUG(D_INODE, "destroying object %Ld\n", oa->o_id);
+ CDEBUG(D_INODE, "destroying object "LPD64"\n", oa->o_id);
dir_dentry = filter_parent(obd, oa->o_mode);
down(&dir_dentry->d_inode->i_sem);
inode = object_dentry->d_inode;
if (inode == NULL) {
- CERROR("trying to destroy negative inode %Ld!\n", oa->o_id);
+ CERROR("trying to destroy negative inode "LPD64"!\n", oa->o_id);
GOTO(out, rc = -ENOENT);
}
if (end != 0xffffffffffffffff)
CERROR("PUNCH not supported, only truncate works\n");
- CDEBUG(D_INODE, "calling truncate for object #%Ld, valid = %x, "
- "o_size = %Ld\n", oa->o_id, oa->o_valid, start);
+ CDEBUG(D_INODE, "calling truncate for object #"LPD64", valid = %x, "
+ "o_size = "LPD64"\n", oa->o_id, oa->o_valid, start);
oa->o_size = start;
error = filter_setattr(conn, oa, NULL);
RETURN(error);
ENTRY;
if (!obd) {
- CDEBUG(D_IOCTL, "invalid client %Lx\n", conn->addr);
+ CDEBUG(D_IOCTL, "invalid client "LPX64"\n", conn->addr);
RETURN(-EINVAL);
}
req = list_entry(tmp, struct ptlrpc_request, rq_list);
if (req->rq_flags & PTL_RPC_FL_REPLAY) {
- CDEBUG(D_INFO, "Keeping req %p xid %Ld for replay\n",
+ CDEBUG(D_INFO, "Keeping req %p xid "LPD64" for replay\n",
req, req->rq_xid);
continue;
}
void ptlrpc_continue_req(struct ptlrpc_request *req)
{
ENTRY;
- CDEBUG(D_INODE, "continue delayed request %Ld opc %d\n",
+ CDEBUG(D_INODE, "continue delayed request "LPD64" opc %d\n",
req->rq_xid, req->rq_reqmsg->opc);
wake_up(&req->rq_wait_for_rep);
EXIT;
void ptlrpc_resend_req(struct ptlrpc_request *req)
{
ENTRY;
- CDEBUG(D_INODE, "resend request %Ld, opc %d\n",
+ CDEBUG(D_INODE, "resend request "LPD64", opc %d\n",
req->rq_xid, req->rq_reqmsg->opc);
req->rq_reqmsg->addr = req->rq_import->imp_handle.addr;
req->rq_reqmsg->cookie = req->rq_import->imp_handle.cookie;
void ptlrpc_restart_req(struct ptlrpc_request *req)
{
ENTRY;
- CDEBUG(D_INODE, "restart completed request %Ld, opc %d\n",
+ CDEBUG(D_INODE, "restart completed request "LPD64", opc %d\n",
req->rq_xid, req->rq_reqmsg->opc);
req->rq_status = -ERESTARTSYS;
req->rq_flags |= PTL_RPC_FL_RECOVERY;
ENTRY;
init_waitqueue_head(&req->rq_wait_for_rep);
- CDEBUG(D_NET, "subsys: %s req %Ld opc %d level %d, conn level %d\n",
+ CDEBUG(D_NET, "subsys: %s req "LPD64" opc %d level %d, conn level %d\n",
cli->cli_name, req->rq_xid, req->rq_reqmsg->opc, req->rq_level,
req->rq_connection->c_level);
GOTO(out, rc = -EINVAL);
}
#endif
- CDEBUG(D_NET, "got rep %Ld\n", req->rq_xid);
+ CDEBUG(D_NET, "got rep "LPD64"\n", req->rq_xid);
if (req->rq_repmsg->status == 0)
CDEBUG(D_NET, "--> buf %p len %d status %d\n", req->rq_repmsg,
req->rq_replen, req->rq_repmsg->status);
ENTRY;
init_waitqueue_head(&req->rq_wait_for_rep);
- CDEBUG(D_NET, "req %Ld opc %d level %d, conn level %d\n",
+ CDEBUG(D_NET, "req "LPD64" opc %d level %d, conn level %d\n",
req->rq_xid, req->rq_reqmsg->opc, req->rq_level,
req->rq_connection->c_level);
GOTO(out, rc);
}
- CDEBUG(D_NET, "got rep %Ld\n", req->rq_xid);
+ CDEBUG(D_NET, "got rep "LPD64"\n", req->rq_xid);
if (req->rq_repmsg->status == 0)
CDEBUG(D_NET, "--> buf %p len %d status %d\n", req->rq_repmsg,
req->rq_replen, req->rq_repmsg->status);
else {
CERROR("recovery failed: ");
- CERROR("req %Ld opc %d level %d, conn level %d\n",
+ CERROR("req "LPD64" opc %d level %d, conn level %d\n",
req->rq_xid, req->rq_reqmsg->opc, req->rq_level,
req->rq_connection->c_level);
LBUG();
#include <linux/obd_support.h>
#include <linux/lustre_net.h>
#include <linux/lustre_lib.h>
+#include <linux/obd.h>
extern ptl_handle_eq_t request_out_eq, reply_in_eq, reply_out_eq,
bulk_source_eq, bulk_sink_eq;
remote_id.nid = conn->c_peer.peer_nid;
remote_id.pid = 0;
- CDEBUG(D_NET, "Sending %d bytes to portal %d, xid %Ld\n",
+ CDEBUG(D_NET, "Sending %d bytes to portal %d, xid "LPD64"\n",
request->rq_req_md.length, portal, request->rq_xid);
if (!portal)
rc = PtlPut(md_h, PTL_NOACK_REQ, remote_id, portal, 0, request->rq_xid,
0, 0);
if (rc != PTL_OK) {
- CERROR("PtlPut(%Lu, %d, %Ld) failed: %d\n", remote_id.nid,
+ CERROR("PtlPut("LPU64", %d, "LPD64") failed: %d\n", remote_id.nid,
portal, request->rq_xid, rc);
PtlMDUnlink(md_h);
}
remote_id.nid = desc->bd_connection->c_peer.peer_nid;
remote_id.pid = 0;
- CDEBUG(D_NET, "Sending %u pages %u bytes to portal %d nid %Lx pid %d xid %d\n",
+ CDEBUG(D_NET, "Sending %u pages %u bytes to portal %d nid "LPX64" pid %d xid %d\n",
desc->bd_md.niov, desc->bd_md.length,
desc->bd_portal, remote_id.nid, remote_id.pid, xid);
rc = PtlPut(desc->bd_md_h, PTL_ACK_REQ, remote_id,
desc->bd_portal, 0, xid, 0, 0);
if (rc != PTL_OK) {
- CERROR("PtlPut(%Lu, %d, %d) failed: %d\n",
+ CERROR("PtlPut("LPU64", %d, %d) failed: %d\n",
remote_id.nid, desc->bd_portal, xid, rc);
PtlMDUnlink(desc->bd_md_h);
LBUG();
GOTO(cleanup2, rc);
}
- CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid %Lu, portal %u\n",
+ CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid "LPU64", portal %u\n",
request->rq_replen, request->rq_xid,
request->rq_import->imp_client->cli_reply_portal);
request.rq_reqlen = event->mem_desc.length;
if (request.rq_reqlen < sizeof(struct lustre_msg)) {
- CERROR("incomplete request (%d): ptl %d from %Lx xid %Ld\n",
+ CERROR("incomplete request (%d): ptl %d from "LPX64" xid "LPD64"\n",
request.rq_reqlen, svc->srv_req_portal,
event->initiator.nid, request.rq_xid);
spin_unlock(&svc->srv_lock);
}
if (request.rq_reqmsg->magic != PTLRPC_MSG_MAGIC) {
- CERROR("wrong lustre_msg magic %d: ptl %d from %Lx xid %Ld\n",
+ CERROR("wrong lustre_msg magic %d: ptl %d from "LPX64" xid "LPD64"\n",
request.rq_reqmsg->magic, svc->srv_req_portal,
event->initiator.nid, request.rq_xid);
spin_unlock(&svc->srv_lock);
}
if (request.rq_reqmsg->version != PTLRPC_MSG_VERSION) {
- CERROR("wrong lustre_msg version %d: ptl %d from %Lx xid %Ld\n",
+ CERROR("wrong lustre_msg version %d: ptl %d from "LPX64" xid "LPD64"\n",
request.rq_reqmsg->version, svc->srv_req_portal,
event->initiator.nid, request.rq_xid);
spin_unlock(&svc->srv_lock);
RETURN(-EINVAL);
}
- CDEBUG(D_NET, "got req %Ld\n", request.rq_xid);
+ CDEBUG(D_NET, "got req "LPD64"\n", request.rq_xid);
request.rq_peer.peer_nid = event->initiator.nid;
/* FIXME: this NI should be the incoming NI.