From cfe57770196510e1c3b9f064fc44e4ad1da373ba Mon Sep 17 00:00:00 2001
From: Yunmi Ha <yunmi.ha@samsung.com>
Date: Thu, 23 Apr 2020 18:10:11 +0900
Subject: [PATCH] cleanup: apply 10mins interval

- When requesting the same or lower level of cleanup again
(warning->warning, full->critical or critical->warning),
do it at a specific interval (10 minutes).

- When requesting the higher level of cleanup again
(warning->critical or critical->full),
do it immediately.

Change-Id: I87adc82a6c761394ff1d876b2729202204441279
Signed-off-by: Yunmi Ha <yunmi.ha@samsung.com>
---
 src/storage/cleanup.c | 85 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 84 insertions(+), 1 deletion(-)

diff --git a/src/storage/cleanup.c b/src/storage/cleanup.c
index 5206aa8..f27f4b1 100644
--- a/src/storage/cleanup.c
+++ b/src/storage/cleanup.c
@@ -24,6 +24,7 @@
 #include <gmodule.h>
 #include <limits.h>
 #include <regex.h>
+#include <time.h>
 
 #include "log.h"
 #include "cleanup.h"
@@ -40,6 +41,12 @@ struct cleanup_request {
 	int level;
 };
 
+struct cleanup_history {
+	enum cleanup_running_type type;
+	int level;
+	time_t tm;
+};
+
 #define REMOVE(path) {	\
 	if(remove(path) != 0) {		\
 		_E("Failed to remove(%s): %d", path, errno);	\
@@ -55,11 +62,14 @@ struct cleanup_request {
 	}	\
 }
 
+#define CLEANUP_INTERVAL_SEC	(10 * 60)
+
 static pthread_mutex_t mutex_cancel;
 static pthread_mutex_t mutex_lock;
 static pthread_t cleanup_th = 0;
 static GList *request_queue = NULL;
 static int cleanup_canceled = 0;
+static GSList *history = NULL;
 
 static int is_cleanup_canceled()
 {
@@ -186,6 +196,70 @@ static int cleanup_recursive(const char *path, GList *except, int target)
 	return ret;
 }
 
+static bool check_history(enum cleanup_running_type type, int level)
+{
+	time_t interval;
+	GSList *list = NULL;
+	struct cleanup_history *item = NULL;
+	bool ret = true;
+
+	/*
+	 * When requesting the same or lower level of cleanup again
+	   (warning->warning, full->critical or critical->warning),
+	   do it at a specific interval (10 minutes).
+
+	 * When requesting the higher level of cleanup again
+	   (warning->critical or critical->full),
+	   do it immediately.
+	*/
+	for (list = history; list != NULL; list = g_slist_next(list)) {
+		item = list->data;
+		if (item->type == type) {
+			if (item->level > level)
+				break;
+
+			interval = time(NULL) - item->tm;
+			if (interval < CLEANUP_INTERVAL_SEC) {
+				//_D("Cleanup(type:%d, level:%d) is already requested before %u seconds.", type, level, (unsigned int)interval);
+				ret = false;
+			}
+
+			break;
+		}
+	}
+
+	return ret;
+}
+
+static void update_history(enum cleanup_running_type type, int level)
+{
+	GSList *list = NULL;
+	struct cleanup_history *item = NULL, *find = NULL;
+
+	for (list = history; list != NULL; list = g_slist_next(list)) {
+		item = list->data;
+		if (item->type == type) {
+			find = item;
+			break;
+		}
+	}
+
+	if (find == NULL) {
+		find = malloc(sizeof(struct cleanup_history));
+		if (!find) {
+			_E("Failed to call malloc function.");
+			return ;
+		}
+		find->type = type;
+		find->level = level;
+		find->tm = time(NULL);
+		history = g_slist_prepend(history, find);
+	} else {
+		find->level = level;
+		find->tm = time(NULL);
+	}
+}
+
 static int add_request_queue(int type, int level)
 {
 	int ret = 0;
@@ -283,7 +357,7 @@ void *cleanup_storage_start(void *arg)
 void cleanup_storage(enum tzplatform_variable path_id, int level)
 {
 	bool bth = (get_request_queue() == NULL);
-	int type = CLEANUP_TYPE_NONE;
+	enum cleanup_running_type type = CLEANUP_TYPE_NONE;
 	int ret;
 
 	if (path_id == TZ_SYS_OPT)
@@ -300,12 +374,17 @@ void cleanup_storage(enum tzplatform_variable path_id, int level)
 		return ;
 	}
 
+	if (!check_history(type, level))
+		return ;
+
 	if (add_request_queue(type, level) != 0) {
 		_E("Failed to add request.");
 		return ;
 	}
 	//_D("Add cleanup request.(type:%d, level:%d)", type, level);
 
+	update_history(type, level);
+
 	if (bth) {
 		ret = pthread_create(&cleanup_th, NULL, cleanup_storage_start, NULL);
 		if (ret != 0)
@@ -329,6 +408,10 @@ void free_cleanup_storage()
 	request_queue = NULL;
 	pthread_mutex_unlock(&mutex_lock);
 
+	if (history)
+		g_slist_free_full(history, free);
+	history = NULL;
+
 	if (cleanup_th) {
 		_D("Cancel cleanup thread %d.", (int)cleanup_th);
 		cleanup_cancel();
-- 
2.7.4