diff --git a/openbsc/include/openbsc/gprs_sgsn.h b/openbsc/include/openbsc/gprs_sgsn.h
index e58b23b..533117a 100644
--- a/openbsc/include/openbsc/gprs_sgsn.h
+++ b/openbsc/include/openbsc/gprs_sgsn.h
@@ -325,7 +325,7 @@
 int gprs_subscr_init(struct sgsn_instance *sgi);
 int gprs_subscr_request_update_location(struct sgsn_mm_ctx *mmctx);
 int gprs_subscr_request_auth_info(struct sgsn_mm_ctx *mmctx);
-void gprs_subscr_delete(struct gsm_subscriber *subscr);
+void gprs_subscr_cleanup(struct gsm_subscriber *subscr);
 struct gsm_subscriber *gprs_subscr_get_or_create(const char *imsi);
 struct gsm_subscriber *gprs_subscr_get_or_create_by_mmctx( struct sgsn_mm_ctx *mmctx);
 struct gsm_subscriber *gprs_subscr_get_by_imsi(const char *imsi);
diff --git a/openbsc/src/gprs/gprs_sgsn.c b/openbsc/src/gprs/gprs_sgsn.c
index fdf4840..490371f 100644
--- a/openbsc/src/gprs/gprs_sgsn.c
+++ b/openbsc/src/gprs/gprs_sgsn.c
@@ -199,7 +199,7 @@
 		struct gsm_subscriber *subscr =  mm->subscr;
 		mm->subscr = NULL;
 		subscr->sgsn_data->mm = NULL;
-		gprs_subscr_delete(subscr);
+		gprs_subscr_cleanup(subscr);
 		subscr_put(subscr);
 	}
 
diff --git a/openbsc/src/gprs/gprs_subscriber.c b/openbsc/src/gprs/gprs_subscriber.c
index b7e6af4..ee6c477 100644
--- a/openbsc/src/gprs/gprs_subscriber.c
+++ b/openbsc/src/gprs/gprs_subscriber.c
@@ -127,7 +127,7 @@
 	return subscr_active_by_imsi(NULL, imsi);
 }
 
-void gprs_subscr_delete(struct gsm_subscriber *subscr)
+void gprs_subscr_cleanup(struct gsm_subscriber *subscr)
 {
 	if (subscr->sgsn_data->mm) {
 		subscr_put(subscr->sgsn_data->mm->subscr);
@@ -150,7 +150,7 @@
 	subscr->flags &= ~GPRS_SUBSCRIBER_ENABLE_PURGE;
 
 	gprs_subscr_update(subscr);
-	gprs_subscr_delete(subscr);
+	gprs_subscr_cleanup(subscr);
 }
 
 static int gprs_subscr_tx_gsup_message(struct gsm_subscriber *subscr,
diff --git a/openbsc/tests/sgsn/sgsn_test.c b/openbsc/tests/sgsn/sgsn_test.c
index 57577a4..5d142da 100644
--- a/openbsc/tests/sgsn/sgsn_test.c
+++ b/openbsc/tests/sgsn/sgsn_test.c
@@ -269,7 +269,7 @@
 	OSMO_ASSERT(last_updated_subscr == s1);
 
 	/* There is no subscriber cache. Verify it */
-	gprs_subscr_delete(s1);
+	gprs_subscr_cleanup(s1);
 	subscr_put(s1);
 	s1 = NULL;
 	sfound = gprs_subscr_get_by_imsi(imsi1);
@@ -279,7 +279,7 @@
 	assert_subscr(s3, imsi3);
 
 	/* Free entry 2 (GSM_SUBSCRIBER_FIRST_CONTACT is set) */
-	gprs_subscr_delete(s2);
+	gprs_subscr_cleanup(s2);
 	subscr_put(s2);
 	s2 = NULL;
 	OSMO_ASSERT(gprs_subscr_get_by_imsi(imsi1) == NULL);
@@ -287,7 +287,7 @@
 	assert_subscr(s3, imsi3);
 
 	/* Try to delete entry 3 */
-	gprs_subscr_delete(s3);
+	gprs_subscr_cleanup(s3);
 	subscr_put(s3);
 	s3 = NULL;
 	OSMO_ASSERT(gprs_subscr_get_by_imsi(imsi3) == NULL);
