DAOS-18196 object: collective object RPC handler uses deep stack

Nasf-Fan · Nasf-Fan · commit 536e91efa67d · 2025-11-19T11:38:51.000+08:00
To avoid potential ULT stack overflow.

Signed-off-by: Fan Yong &lt;fan.yong@hpe.com&gt;
diff --git a/src/container/srv_container.c b/src/container/srv_container.c
@@ -2245,7 +2245,7 @@ cont_svc_eph_track_leader_start(struct cont_svc *svc)
 
 	D_ASSERT(svc->cs_cont_ephs_leader_req == NULL);
 	uuid_clear(anonym_uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &anonym_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &anonym_uuid);
 	svc->cs_cont_ephs_leader_req = sched_create_ult(&attr, cont_track_eph_leader_ult, svc, 0);
 	if (svc->cs_cont_ephs_leader_req == NULL) {
 		D_ERROR(DF_UUID" Failed to create EC leader eph ULT.\n",
diff --git a/src/container/srv_target.c b/src/container/srv_target.c
@@ -602,7 +602,7 @@ cont_start_agg(struct ds_cont_child *cont)
 	struct dss_module_info	*dmi = dss_get_module_info();
 	struct sched_req_attr	 attr;
 
-	sched_req_attr_init(&attr, SCHED_REQ_GC, &cont->sc_pool->spc_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_GC, 0, &cont->sc_pool->spc_uuid);
 
 	if (likely(!ec_agg_disabled)) {
 		D_ASSERT(cont->sc_ec_agg_req == NULL);
@@ -1277,7 +1277,7 @@ cont_destroy_wait(struct ds_pool_child *child, uuid_t co_uuid)
 		DP_CONT(child->spc_uuid, co_uuid));
 
 	D_ASSERT(child != NULL);
-	sched_req_attr_init(&attr, SCHED_REQ_FETCH, &child->spc_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_FETCH, 0, &child->spc_uuid);
 	req = sched_req_get(&attr, ABT_THREAD_NULL);
 	if (req == NULL) {
 		D_CRIT(DF_UUID"[%d]: Failed to get sched req\n",
diff --git a/src/dtx/dtx_common.c b/src/dtx/dtx_common.c
@@ -473,7 +473,7 @@ dtx_aggregation_pool(struct dss_module_info *dmi, struct dtx_batched_pool_args *
 	struct dtx_tls			*tls = dtx_tls_get();
 
 	D_ASSERT(dbpa->dbpa_pool);
-	sched_req_attr_init(&attr, SCHED_REQ_GC, &dbpa->dbpa_pool->spc_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_GC, 0, &dbpa->dbpa_pool->spc_uuid);
 
 	while (!dss_xstream_exiting(dmi->dmi_xstream)) {
 		struct dtx_stat		 stat = { 0 };
@@ -585,7 +585,7 @@ dtx_aggregation_main(void *arg)
 	uuid_t				 anonym_uuid;
 
 	uuid_clear(anonym_uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &anonym_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &anonym_uuid);
 
 	D_ASSERT(dmi->dmi_dtx_agg_req == NULL);
 	dmi->dmi_dtx_agg_req = sched_req_get(&attr, ABT_THREAD_NULL);
@@ -705,7 +705,7 @@ dtx_batched_commit(void *arg)
 	uuid_t				 anonym_uuid;
 
 	uuid_clear(anonym_uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &anonym_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &anonym_uuid);
 
 	D_ASSERT(dmi->dmi_dtx_cmt_req == NULL);
 	dmi->dmi_dtx_cmt_req = sched_req_get(&attr, ABT_THREAD_NULL);
@@ -757,7 +757,7 @@ dtx_batched_commit(void *arg)
 			dtx_get_dbca(dbca);
 
 			D_ASSERT(dbca->dbca_cont);
-			sched_req_attr_init(&attr, SCHED_REQ_GC, &dbca->dbca_cont->sc_pool_uuid);
+			sched_req_attr_init(&attr, SCHED_REQ_GC, 0, &dbca->dbca_cont->sc_pool_uuid);
 			dbca->dbca_commit_req = sched_create_ult(&attr, dtx_batched_commit_one,
 								 dbca, 0);
 			if (dbca->dbca_commit_req == NULL) {
@@ -781,7 +781,7 @@ dtx_batched_commit(void *arg)
 			dtx_get_dbca(dbca);
 
 			D_ASSERT(dbca->dbca_cont);
-			sched_req_attr_init(&attr, SCHED_REQ_GC, &dbca->dbca_cont->sc_pool_uuid);
+			sched_req_attr_init(&attr, SCHED_REQ_GC, 0, &dbca->dbca_cont->sc_pool_uuid);
 			dbca->dbca_cleanup_req = sched_create_ult(&attr, dtx_cleanup, dbca, 0);
 			if (dbca->dbca_cleanup_req == NULL) {
 				D_WARN("Fail to start DTX ULT (3) for "DF_UUID"\n",
diff --git a/src/engine/drpc_client.c b/src/engine/drpc_client.c
@@ -116,7 +116,7 @@ dss_drpc_call(int32_t module, int32_t method, void *req, size_t req_size,
 
 	/* Initialize sched_req for the backoffs below. */
 	uuid_clear(anonym_uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &anonym_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &anonym_uuid);
 	sched_req = sched_req_get(&attr, ABT_THREAD_NULL);
 	if (sched_req == NULL) {
 		D_ERROR("failed to get sched req\n");
diff --git a/src/engine/sched.c b/src/engine/sched.c
@@ -746,12 +746,17 @@ static inline int
 req_kickoff_internal(struct dss_xstream *dx, struct sched_req_attr *attr,
 		     void (*func)(void *), void *arg)
 {
+	uint32_t flags = 0;
+
 	D_ASSERT(attr && func && arg);
 	D_ASSERT(attr->sra_type < SCHED_REQ_TYPE_MAX);
 
-	return sched_create_thread(dx, func, arg, ABT_THREAD_ATTR_NULL, NULL,
-				   attr->sra_flags & SCHED_REQ_FL_PERIODIC ?
-					DSS_ULT_FL_PERIODIC : 0);
+	if (attr->sra_flags & SCHED_REQ_FL_PERIODIC)
+		flags |= DSS_ULT_FL_PERIODIC;
+	if (attr->sra_flags & SCHED_REQ_FL_DEEP_STACK)
+		flags |= DSS_ULT_DEEP_STACK;
+
+	return sched_create_thread(dx, func, arg, ABT_THREAD_ATTR_NULL, NULL, flags);
 }
 
 static int
diff --git a/src/engine/srv.c b/src/engine/srv.c
@@ -223,7 +223,7 @@ dss_sleep(uint64_t msec)
 	uuid_t			 anonym_uuid;
 
 	uuid_clear(anonym_uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &anonym_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &anonym_uuid);
 	req = sched_req_get(&attr, ABT_THREAD_NULL);
 	if (req == NULL)
 		return -DER_NOMEM;
diff --git a/src/include/daos_srv/daos_engine.h b/src/include/daos_srv/daos_engine.h
@@ -158,10 +158,11 @@ enum {
 };
 
 enum {
-	SCHED_REQ_FL_NO_DELAY	= (1 << 0),
-	SCHED_REQ_FL_PERIODIC	= (1 << 1),
-	SCHED_REQ_FL_NO_REJECT	= (1 << 2),
-	SCHED_REQ_FL_RESENT	= (1 << 3),
+	SCHED_REQ_FL_NO_DELAY   = (1 << 0),
+	SCHED_REQ_FL_PERIODIC   = (1 << 1),
+	SCHED_REQ_FL_NO_REJECT  = (1 << 2),
+	SCHED_REQ_FL_RESENT     = (1 << 3),
+	SCHED_REQ_FL_DEEP_STACK = (1 << 4),
 };
 
 struct sched_req_attr {
@@ -174,11 +175,10 @@ struct sched_req_attr {
 };
 
 static inline void
-sched_req_attr_init(struct sched_req_attr *attr, unsigned int type,
-		    uuid_t *pool_id)
+sched_req_attr_init(struct sched_req_attr *attr, uint32_t type, uint32_t flags, uuid_t *pool_id)
 {
-	attr->sra_type = type;
-	attr->sra_flags = 0;
+	attr->sra_type  = type;
+	attr->sra_flags = flags;
 	uuid_copy(attr->sra_pool_id, *pool_id);
 }
 
diff --git a/src/object/srv_coll.c b/src/object/srv_coll.c
@@ -70,7 +70,8 @@ obj_coll_local(crt_rpc_t *rpc, struct daos_coll_shard *shards, struct dtx_coll_e
 	coll_args.ca_tgt_bitmap = dce->dce_bitmap;
 	coll_args.ca_tgt_bitmap_sz = dce->dce_bitmap_sz;
 
-	rc = dss_thread_collective_reduce(&coll_ops, &coll_args, DSS_USE_CURRENT_ULT);
+	rc = dss_thread_collective_reduce(&coll_ops, &coll_args,
+					  DSS_ULT_DEEP_STACK | DSS_USE_CURRENT_ULT);
 
 out:
 	if (octa.octa_versions != NULL) {
diff --git a/src/object/srv_mod.c b/src/object/srv_mod.c
@@ -229,14 +229,14 @@ obj_get_req_attr(crt_rpc_t *rpc, struct sched_req_attr *attr)
 			type = SCHED_REQ_UPDATE;
 		else
 			type = SCHED_REQ_FETCH;
-		sched_req_attr_init(attr, type, &orw->orw_pool_uuid);
+		sched_req_attr_init(attr, type, 0, &orw->orw_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_MIGRATE: {
 		struct obj_migrate_in *omi = crt_req_get(rpc);
 
 		attr->sra_enqueue_id = omi->om_comm_in.req_in_enqueue_id;
-		sched_req_attr_init(attr, SCHED_REQ_MIGRATE, &omi->om_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_MIGRATE, 0, &omi->om_pool_uuid);
 		break;
 	}
 	/*
@@ -258,7 +258,7 @@ obj_get_req_attr(crt_rpc_t *rpc, struct sched_req_attr *attr)
 			attr->sra_enqueue_id = oei_v10->oei_comm_in.req_in_enqueue_id;
 		}
 		type = (oei->oei_flags & ORF_FOR_MIGRATION) ? SCHED_REQ_MIGRATE : SCHED_REQ_ANONYM;
-		sched_req_attr_init(attr, type, &oei->oei_pool_uuid);
+		sched_req_attr_init(attr, type, 0, &oei->oei_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_PUNCH:
@@ -274,7 +274,7 @@ obj_get_req_attr(crt_rpc_t *rpc, struct sched_req_attr *attr)
 
 			attr->sra_enqueue_id = opi_v10->opi_comm_in.req_in_enqueue_id;
 		}
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &opi->opi_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &opi->opi_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_QUERY_KEY: {
@@ -285,7 +285,7 @@ obj_get_req_attr(crt_rpc_t *rpc, struct sched_req_attr *attr)
 
 			attr->sra_enqueue_id = okqi_v10->okqi_comm_in.req_in_enqueue_id;
 		}
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &okqi->okqi_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &okqi->okqi_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_SYNC: {
@@ -296,7 +296,7 @@ obj_get_req_attr(crt_rpc_t *rpc, struct sched_req_attr *attr)
 
 			attr->sra_enqueue_id = osi_v10->osi_comm_in.req_in_enqueue_id;
 		}
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &osi->osi_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &osi->osi_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_KEY2ANCHOR: {
@@ -307,41 +307,43 @@ obj_get_req_attr(crt_rpc_t *rpc, struct sched_req_attr *attr)
 
 			attr->sra_enqueue_id = oki_v10->oki_comm_in.req_in_enqueue_id;
 		}
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &oki->oki_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &oki->oki_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_EC_AGGREGATE: {
 		struct obj_ec_agg_in *ea = crt_req_get(rpc);
 
 		attr->sra_enqueue_id = ea->ea_comm_in.req_in_enqueue_id;
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &ea->ea_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &ea->ea_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_EC_REPLICATE: {
 		struct obj_ec_rep_in *er = crt_req_get(rpc);
 
 		attr->sra_enqueue_id = er->er_comm_in.req_in_enqueue_id;
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &er->er_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &er->er_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_CPD: {
 		struct obj_cpd_in *oci = crt_req_get(rpc);
 
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &oci->oci_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &oci->oci_pool_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_COLL_PUNCH: {
 		struct obj_coll_punch_in *ocpi = crt_req_get(rpc);
 
 		attr->sra_enqueue_id = ocpi->ocpi_comm_in.req_in_enqueue_id;
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &ocpi->ocpi_po_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, SCHED_REQ_FL_DEEP_STACK,
+				    &ocpi->ocpi_po_uuid);
 		break;
 	}
 	case DAOS_OBJ_RPC_COLL_QUERY: {
 		struct obj_coll_query_in *ocqi = crt_req_get(rpc);
 
 		attr->sra_enqueue_id = ocqi->ocqi_comm_in.req_in_enqueue_id;
-		sched_req_attr_init(attr, SCHED_REQ_ANONYM, &ocqi->ocqi_po_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_ANONYM, SCHED_REQ_FL_DEEP_STACK,
+				    &ocqi->ocqi_po_uuid);
 		break;
 	}
 	default:
diff --git a/src/pool/srv_pool.c b/src/pool/srv_pool.c
@@ -1630,7 +1630,7 @@ start_event_timer(struct event_timer_arg *arg)
 
 	D_ASSERT(events->pse_timer == NULL);
 	uuid_clear(uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &uuid);
 	events->pse_timer = sched_create_ult(&attr, event_timer, arg, 0);
 	if (events->pse_timer == NULL)
 		return -DER_NOMEM;
diff --git a/src/pool/srv_pool_chkpt.c b/src/pool/srv_pool_chkpt.c
@@ -1,5 +1,6 @@
 /*
  * (C) Copyright 2023 Intel Corporation.
+ * (C) Copyright 2025 Hewlett Packard Enterprise Development LP
  *
  * SPDX-License-Identifier: BSD-2-Clause-Patent
  */
@@ -242,7 +243,7 @@ ds_start_chkpt_ult(struct ds_pool_child *child)
 	/** We probably need something that runs with higher priority than GC but start with
 	 *  that for now.
 	 */
-	sched_req_attr_init(&attr, SCHED_REQ_GC, &child->spc_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_GC, 0, &child->spc_uuid);
 	child->spc_chkpt_req = sched_create_ult(&attr, chkpt_ult, child, DSS_DEEP_STACK_SZ);
 	if (child->spc_chkpt_req == NULL) {
 		D_ERROR(DF_UUID "[%d]: Failed to create checkpoint ULT.\n",
diff --git a/src/pool/srv_pool_scrub_ult.c b/src/pool/srv_pool_scrub_ult.c
@@ -382,7 +382,7 @@ ds_start_scrubbing_ult(struct ds_pool_child *child)
 	/* There will be several levels iteration, such as pool, container, object, and lower,
 	 * and so on. Let's use DSS_DEEP_STACK_SZ to avoid ULT overflow.
 	 */
-	sched_req_attr_init(&attr, SCHED_REQ_SCRUB, &child->spc_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_SCRUB, 0, &child->spc_uuid);
 	child->spc_scrubbing_req = sched_create_ult(&attr, scrubbing_ult, child,
 						    DSS_DEEP_STACK_SZ);
 	if (child->spc_scrubbing_req == NULL) {
diff --git a/src/pool/srv_target.c b/src/pool/srv_target.c
@@ -207,7 +207,7 @@ start_gc_ult(struct ds_pool_child *child)
 	D_DEBUG(DB_MGMT, DF_UUID"[%d]: starting GC ULT\n",
 		DP_UUID(child->spc_uuid), dmi->dmi_tgt_id);
 
-	sched_req_attr_init(&attr, SCHED_REQ_GC, &child->spc_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_GC, 0, &child->spc_uuid);
 	attr.sra_flags = SCHED_REQ_FL_NO_DELAY;
 
 	child->spc_gc_req = sched_create_ult(&attr, gc_ult, child, DSS_DEEP_STACK_SZ);
@@ -269,7 +269,7 @@ start_flush_ult(struct ds_pool_child *child)
 	D_ASSERT(child != NULL);
 	D_ASSERT(child->spc_flush_req == NULL);
 
-	sched_req_attr_init(&attr, SCHED_REQ_GC, &child->spc_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_GC, 0, &child->spc_uuid);
 	attr.sra_flags = SCHED_REQ_FL_NO_DELAY;
 
 	child->spc_flush_req = sched_create_ult(&attr, flush_ult, child, DSS_DEEP_STACK_SZ);
@@ -1226,7 +1226,7 @@ start_eph_report_ult(struct ds_pool *pool)
 
 	D_ASSERT(pool->sp_ec_ephs_req == NULL);
 	uuid_clear(anonym_uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &anonym_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &anonym_uuid);
 	pool->sp_ec_ephs_req = sched_create_ult(&attr, eph_report_ult, pool, DSS_DEEP_STACK_SZ);
 	if (pool->sp_ec_ephs_req == NULL) {
 		D_ERROR(DF_UUID ": Failed to create eph report ULT.\n", DP_UUID(pool->sp_uuid));
diff --git a/src/rdb/rdb_raft.c b/src/rdb/rdb_raft.c
@@ -2186,7 +2186,7 @@ rdb_timerd(void *arg)
 	D_DEBUG(DB_MD, DF_DB": timerd starting\n", DP_DB(db));
 
 	uuid_clear(anonym_uuid);
-	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, &anonym_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_ANONYM, 0, &anonym_uuid);
 	sched_req = sched_req_get(&attr, ABT_THREAD_NULL);
 	if (sched_req == NULL) {
 		D_ERROR(DF_DB": failed to get sched req.\n", DP_DB(db));
@@ -3505,4 +3505,4 @@ rdb_raft_module_init(void)
 void
 rdb_raft_module_fini(void)
 {
-}
+}
diff --git a/src/rebuild/srv.c b/src/rebuild/srv.c
@@ -944,7 +944,7 @@ rebuild_leader_status_check(struct ds_pool *pool, uint32_t op,
 	if (rc)
 		return;
 
-	sched_req_attr_init(&attr, SCHED_REQ_MIGRATE, &rgt->rgt_pool_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_MIGRATE, 0, &rgt->rgt_pool_uuid);
 	rgt->rgt_ult = sched_req_get(&attr, ABT_THREAD_NULL);
 	if (rgt->rgt_ult == NULL)
 		return;
@@ -2777,7 +2777,7 @@ rebuild_tgt_status_check_ult(void *arg)
 	struct sched_req_attr	attr = { 0 };
 
 	D_ASSERT(rpt != NULL);
-	sched_req_attr_init(&attr, SCHED_REQ_MIGRATE, &rpt->rt_pool_uuid);
+	sched_req_attr_init(&attr, SCHED_REQ_MIGRATE, 0, &rpt->rt_pool_uuid);
 	rpt->rt_ult = sched_req_get(&attr, ABT_THREAD_NULL);
 	if (rpt->rt_ult == NULL) {
 		D_ERROR("Can not start rebuild status check\n");
@@ -3209,7 +3209,7 @@ rebuild_get_req_attr(crt_rpc_t *rpc, struct sched_req_attr *attr)
 	if (opc_get(rpc->cr_opc) == REBUILD_OBJECTS_SCAN) {
 		struct rebuild_scan_in *rsi = crt_req_get(rpc);
 
-		sched_req_attr_init(attr, SCHED_REQ_MIGRATE, &rsi->rsi_pool_uuid);
+		sched_req_attr_init(attr, SCHED_REQ_MIGRATE, 0, &rsi->rsi_pool_uuid);
 	}
 
 	return 0;

Original file line number	Diff line number	Diff line change
`@@ -229,14 +229,14 @@ obj_get_req_attr(crt_rpc_t rpc, struct sched_req_attr attr)`
`229`	`229`	`type = SCHED_REQ_UPDATE;`
`230`	`230`	`else`
`231`	`231`	`type = SCHED_REQ_FETCH;`
`232`		`- sched_req_attr_init(attr, type, &orw->orw_pool_uuid);`
	`232`	`+ sched_req_attr_init(attr, type, 0, &orw->orw_pool_uuid);`
`233`	`233`	`break;`
`234`	`234`	`}`
`235`	`235`	`case DAOS_OBJ_RPC_MIGRATE: {`
`236`	`236`	`struct obj_migrate_in *omi = crt_req_get(rpc);`
`237`	`237`
`238`	`238`	`attr->sra_enqueue_id = omi->om_comm_in.req_in_enqueue_id;`
`239`		`- sched_req_attr_init(attr, SCHED_REQ_MIGRATE, &omi->om_pool_uuid);`
	`239`	`+ sched_req_attr_init(attr, SCHED_REQ_MIGRATE, 0, &omi->om_pool_uuid);`
`240`	`240`	`break;`
`241`	`241`	`}`
`242`	`242`	`/*`
`@@ -258,7 +258,7 @@ obj_get_req_attr(crt_rpc_t rpc, struct sched_req_attr attr)`
`258`	`258`	`attr->sra_enqueue_id = oei_v10->oei_comm_in.req_in_enqueue_id;`
`259`	`259`	`}`
`260`	`260`	`type = (oei->oei_flags & ORF_FOR_MIGRATION) ? SCHED_REQ_MIGRATE : SCHED_REQ_ANONYM;`
`261`		`- sched_req_attr_init(attr, type, &oei->oei_pool_uuid);`
	`261`	`+ sched_req_attr_init(attr, type, 0, &oei->oei_pool_uuid);`
`262`	`262`	`break;`
`263`	`263`	`}`
`264`	`264`	`case DAOS_OBJ_RPC_PUNCH:`
`@@ -274,7 +274,7 @@ obj_get_req_attr(crt_rpc_t rpc, struct sched_req_attr attr)`
`274`	`274`
`275`	`275`	`attr->sra_enqueue_id = opi_v10->opi_comm_in.req_in_enqueue_id;`
`276`	`276`	`}`
`277`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &opi->opi_pool_uuid);`
	`277`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &opi->opi_pool_uuid);`
`278`	`278`	`break;`
`279`	`279`	`}`
`280`	`280`	`case DAOS_OBJ_RPC_QUERY_KEY: {`
`@@ -285,7 +285,7 @@ obj_get_req_attr(crt_rpc_t rpc, struct sched_req_attr attr)`
`285`	`285`
`286`	`286`	`attr->sra_enqueue_id = okqi_v10->okqi_comm_in.req_in_enqueue_id;`
`287`	`287`	`}`
`288`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &okqi->okqi_pool_uuid);`
	`288`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &okqi->okqi_pool_uuid);`
`289`	`289`	`break;`
`290`	`290`	`}`
`291`	`291`	`case DAOS_OBJ_RPC_SYNC: {`
`@@ -296,7 +296,7 @@ obj_get_req_attr(crt_rpc_t rpc, struct sched_req_attr attr)`
`296`	`296`
`297`	`297`	`attr->sra_enqueue_id = osi_v10->osi_comm_in.req_in_enqueue_id;`
`298`	`298`	`}`
`299`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &osi->osi_pool_uuid);`
	`299`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &osi->osi_pool_uuid);`
`300`	`300`	`break;`
`301`	`301`	`}`
`302`	`302`	`case DAOS_OBJ_RPC_KEY2ANCHOR: {`
`@@ -307,41 +307,43 @@ obj_get_req_attr(crt_rpc_t rpc, struct sched_req_attr attr)`
`307`	`307`
`308`	`308`	`attr->sra_enqueue_id = oki_v10->oki_comm_in.req_in_enqueue_id;`
`309`	`309`	`}`
`310`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &oki->oki_pool_uuid);`
	`310`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &oki->oki_pool_uuid);`
`311`	`311`	`break;`
`312`	`312`	`}`
`313`	`313`	`case DAOS_OBJ_RPC_EC_AGGREGATE: {`
`314`	`314`	`struct obj_ec_agg_in *ea = crt_req_get(rpc);`
`315`	`315`
`316`	`316`	`attr->sra_enqueue_id = ea->ea_comm_in.req_in_enqueue_id;`
`317`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &ea->ea_pool_uuid);`
	`317`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &ea->ea_pool_uuid);`
`318`	`318`	`break;`
`319`	`319`	`}`
`320`	`320`	`case DAOS_OBJ_RPC_EC_REPLICATE: {`
`321`	`321`	`struct obj_ec_rep_in *er = crt_req_get(rpc);`
`322`	`322`
`323`	`323`	`attr->sra_enqueue_id = er->er_comm_in.req_in_enqueue_id;`
`324`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &er->er_pool_uuid);`
	`324`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &er->er_pool_uuid);`
`325`	`325`	`break;`
`326`	`326`	`}`
`327`	`327`	`case DAOS_OBJ_RPC_CPD: {`
`328`	`328`	`struct obj_cpd_in *oci = crt_req_get(rpc);`
`329`	`329`
`330`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &oci->oci_pool_uuid);`
	`330`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, 0, &oci->oci_pool_uuid);`
`331`	`331`	`break;`
`332`	`332`	`}`
`333`	`333`	`case DAOS_OBJ_RPC_COLL_PUNCH: {`
`334`	`334`	`struct obj_coll_punch_in *ocpi = crt_req_get(rpc);`
`335`	`335`
`336`	`336`	`attr->sra_enqueue_id = ocpi->ocpi_comm_in.req_in_enqueue_id;`
`337`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &ocpi->ocpi_po_uuid);`
	`337`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, SCHED_REQ_FL_DEEP_STACK,`
	`338`	`+ &ocpi->ocpi_po_uuid);`
`338`	`339`	`break;`
`339`	`340`	`}`
`340`	`341`	`case DAOS_OBJ_RPC_COLL_QUERY: {`
`341`	`342`	`struct obj_coll_query_in *ocqi = crt_req_get(rpc);`
`342`	`343`
`343`	`344`	`attr->sra_enqueue_id = ocqi->ocqi_comm_in.req_in_enqueue_id;`
`344`		`- sched_req_attr_init(attr, SCHED_REQ_ANONYM, &ocqi->ocqi_po_uuid);`
	`345`	`+ sched_req_attr_init(attr, SCHED_REQ_ANONYM, SCHED_REQ_FL_DEEP_STACK,`
	`346`	`+ &ocqi->ocqi_po_uuid);`
`345`	`347`	`break;`
`346`	`348`	`}`
`347`	`349`	`default:`