diff --git a/src/libmsc/msc_net_init.c b/src/libmsc/msc_net_init.c
index 8c8fb86..adb9ca7 100644
--- a/src/libmsc/msc_net_init.c
+++ b/src/libmsc/msc_net_init.c
@@ -67,9 +67,6 @@
 	net->a5_encryption_mask = (1 << 3) | (1 << 1);
 	net->uea_encryption = true;
 
-	/* Use 30 min periodic update interval as sane default */
-	net->t3212 = 5;
-
 	net->mncc_guard_timeout = 180;
 	net->ncss_guard_timeout = 30;
 
diff --git a/src/libmsc/msc_vty.c b/src/libmsc/msc_vty.c
index 53d44dc..e2e892a 100644
--- a/src/libmsc/msc_vty.c
+++ b/src/libmsc/msc_vty.c
@@ -303,32 +303,44 @@
 	return CMD_SUCCESS;
 }
 
-DEFUN(cfg_net_per_loc_upd, cfg_net_per_loc_upd_cmd,
-      "periodic location update <6-1530>",
-      "Periodic Location Updating Interval\n"
-      "Periodic Location Updating Interval\n"
-      "Periodic Location Updating Interval\n"
-      "Periodic Location Updating Interval in Minutes\n")
+/* NOTE: actually this is subscriber expiration timeout */
+#define PER_LOC_UPD_STR "Periodic Location Updating Interval\n"
+
+DEFUN_DEPRECATED(cfg_net_per_loc_upd, cfg_net_per_loc_upd_cmd,
+		 "periodic location update <6-1530>",
+		 PER_LOC_UPD_STR PER_LOC_UPD_STR PER_LOC_UPD_STR
+		 "Periodic Location Updating Interval in Minutes\n")
 {
-	struct gsm_network *net = vty->index;
+	int minutes = atoi(argv[0]);
+	int rc;
 
-	net->t3212 = atoi(argv[0]) / 6;
+	vty_out(vty, "%% 'periodic location update' is now deprecated: "
+		     "use 'timer T3212' to change subscriber expiration "
+		     "timeout.%s", VTY_NEWLINE);
 
-	return CMD_SUCCESS;
+	/* We used to double this value and add a minute when scheduling the
+	 * expiration timer. Let's emulate the old behaviour here. */
+	minutes = minutes * 2 + 1;
+	vty_out(vty, "%% Setting T3212 to %d minutes "
+		     "(emulating the old behaviour).%s",
+		     minutes, VTY_NEWLINE);
+
+	rc = osmo_tdef_set(msc_tdefs_vlr, 3212, minutes, OSMO_TDEF_M);
+	return rc ? CMD_WARNING : CMD_SUCCESS;
 }
 
-DEFUN(cfg_net_no_per_loc_upd, cfg_net_no_per_loc_upd_cmd,
-      "no periodic location update",
-      NO_STR
-      "Periodic Location Updating Interval\n"
-      "Periodic Location Updating Interval\n"
-      "Periodic Location Updating Interval\n")
+DEFUN_DEPRECATED(cfg_net_no_per_loc_upd, cfg_net_no_per_loc_upd_cmd,
+		 "no periodic location update",
+		 NO_STR PER_LOC_UPD_STR PER_LOC_UPD_STR PER_LOC_UPD_STR)
 {
-	struct gsm_network *net = vty->index;
+	int rc;
 
-	net->t3212 = 0;
+	vty_out(vty, "%% 'periodic location update' is now deprecated: "
+		     "use 'timer T3212' to change subscriber expiration "
+		     "timeout.%s", VTY_NEWLINE);
 
-	return CMD_SUCCESS;
+	rc = osmo_tdef_set(msc_tdefs_vlr, 3212, 0, OSMO_TDEF_M);
+	return rc ? CMD_WARNING : CMD_SUCCESS;
 }
 
 DEFUN(cfg_net_call_wait, cfg_net_call_wait_cmd,
@@ -389,11 +401,6 @@
 			vty_out(vty, " timezone %d %d%s",
 				gsmnet->tz.hr, gsmnet->tz.mn, VTY_NEWLINE);
 	}
-	if (gsmnet->t3212 == 0)
-		vty_out(vty, " no periodic location update%s", VTY_NEWLINE);
-	else
-		vty_out(vty, " periodic location update %u%s",
-			gsmnet->t3212 * 6, VTY_NEWLINE);
 
 	if (gsmnet->emergency.route_to_msisdn) {
 		vty_out(vty, " emergency-call route-to-msisdn %s%s",
@@ -869,7 +876,6 @@
 static void vty_dump_one_subscr(struct vty *vty, struct vlr_subscr *vsub,
 				int offset, uint8_t dump_flags)
 {
-	struct gsm_network *net;
 	struct timespec now;
 	char buf[128];
 
@@ -943,9 +949,7 @@
 			     VTY_NEWLINE);
 	}
 
-	/* XXX move t3212 into struct vlr_instance? */
-	net = vsub->vlr->user_ctx;
-	if (!net->t3212) {
+	if (!vlr_timer(vsub->vlr, 3212)) {
 		MSC_VTY_DUMP(vty, offset, "Expires: never (T3212 is disabled)%s",
 			     VTY_NEWLINE);
 	} else if (vsub->expire_lu == VLR_SUBSCRIBER_NO_EXPIRATION) {
diff --git a/src/libvlr/vlr.c b/src/libvlr/vlr.c
index a1489f2..887ceb8 100644
--- a/src/libvlr/vlr.c
+++ b/src/libvlr/vlr.c
@@ -64,7 +64,7 @@
 
 /* 3GPP TS 24.008, table 11.2 Mobility management timers (network-side) */
 struct osmo_tdef msc_tdefs_vlr[] = {
-	/* TODO: also define T3212 here */
+	{ .T = 3212, .default_val = 60, .unit = OSMO_TDEF_M, .desc = "Subscriber expiration timeout" },
 	{ .T = 3250, .default_val = 12, .desc = "TMSI Reallocation procedure" },
 	{ .T = 3260, .default_val = 12, .desc = "Authentication procedure" },
 	{ .T = 3270, .default_val = 12, .desc = "Identification procedure" },
@@ -75,6 +75,9 @@
  * TODO: we should start using osmo_tdef_fsm_inst_state_chg() */
 uint32_t vlr_timer(struct vlr_instance *vlr, uint32_t timer)
 {
+	/* NOTE: since we usually do not need more than one instance of the VLR,
+	 * and since libosmocore's osmo_tdef API does not (yet) support dynamic
+	 * configuration, we always use the global instance of msc_tdefs_vlr. */
 	return osmo_tdef_get(msc_tdefs_vlr, timer, OSMO_TDEF_S, 0);
 }
 
@@ -496,14 +499,11 @@
 
 void vlr_subscr_enable_expire_lu(struct vlr_subscr *vsub)
 {
-	struct gsm_network *net = vsub->vlr->user_ctx; /* XXX move t3212 into struct vlr_instance? */
 	struct timespec now;
 
-	/* The T3212 timeout value field is coded as the binary representation of the timeout
-	 * value for periodic updating in decihours. Mark the subscriber as inactive if it missed
-	 * two consecutive location updates. Timeout is twice the t3212 value plus one minute. */
+	/* Mark the subscriber as inactive if it stopped to do periodical location updates. */
 	if (osmo_clock_gettime(CLOCK_MONOTONIC, &now) == 0) {
-		vsub->expire_lu = now.tv_sec + (net->t3212 * 60 * 6 * 2) + 60;
+		vsub->expire_lu = now.tv_sec + vlr_timer(vsub->vlr, 3212);
 	} else {
 		LOGP(DVLR, LOGL_ERROR,
 		     "%s: Could not enable Location Update expiry: unable to read current time\n", vlr_subscr_name(vsub));
@@ -516,13 +516,11 @@
 {
 	struct vlr_instance *vlr = data;
 	struct vlr_subscr *vsub, *vsub_tmp;
-	struct gsm_network *net;
 	struct timespec now;
 
 	/* Periodic location update might be disabled from the VTY,
 	 * so we shall not expire subscribers until explicit IMSI Detach. */
-	net = vlr->user_ctx; /* XXX move t3212 into struct vlr_instance? */
-	if (!net->t3212)
+	if (!vlr_timer(vlr, 3212))
 		goto done;
 
 	if (llist_empty(&vlr->subscribers))
@@ -1263,6 +1261,9 @@
 	/* defaults */
 	vlr->cfg.assign_tmsi = true;
 
+	/* reset shared timer definitions */
+	osmo_tdefs_reset(msc_tdefs_vlr);
+
 	/* osmo_auth_fsm.c */
 	OSMO_ASSERT(osmo_fsm_register(&vlr_auth_fsm) == 0);
 	/* osmo_lu_fsm.c */
