RDK-59221: Enable Accumulate Support For Grep Markers in Telemetry Profiles

source/bulkdata/profile.c

@@ -452,25 +452,22 @@ static void* CollectAndReport(void* data)
                 }
                 if(profile->topMarkerList != NULL && Vector_Size(profile->topMarkerList) > 0)
                 {
-                    Vector *topMarkerResultList = NULL;
-                    Vector_Create(&topMarkerResultList);
-                    processTopPattern(profile->name, profile->topMarkerList, topMarkerResultList, 0);
-                    long int reportSize = Vector_Size(topMarkerResultList);
+                    processTopPattern(profile->name, profile->topMarkerList, 0);
+                    long int reportSize = Vector_Size(profile->topMarkerList);
                     if(reportSize != 0)
                     {
-                        T2Info("Top markers report is compleated report size %ld\n", (unsigned long)reportSize);
-                        encodeGrepResultInJSON(valArray, topMarkerResultList);
+                        T2Info("Top markers report is completed report size %ld\n", (unsigned long)reportSize);
+                        encodeGrepResultInJSON(valArray, profile->topMarkerList);
                     }
                     else
                     {
                         T2Debug("Top markers report generated but is empty possabliy the memory value is changed");
                     }
-                    Vector_Destroy(topMarkerResultList, freeGResult);
                 }
                 if(profile->gMarkerList != NULL && Vector_Size(profile->gMarkerList) > 0)
                 {
                     getGrepResults(&(profile->grepSeekProfile), profile->gMarkerList, &grepResultList, profile->bClearSeekMap, false, customLogPath); // Passing 5th argument as false so that it doesn't check rotated logs for the first reporting after bootup for multiprofiles.
-                    encodeGrepResultInJSON(valArray, grepResultList);
+                    encodeGrepResultInJSON(valArray, profile->gMarkerList);
                     Vector_Destroy(grepResultList, freeGResult);
                 }
                 if(profile->eMarkerList != NULL && Vector_Size(profile->eMarkerList) > 0)

source/dcautil/dca.c

@@ -165,10 +165,10 @@ static pthread_mutex_t dcaMutex = PTHREAD_MUTEX_INITIALIZER;
  *  @return  Returns the status of the operation.
  *  @retval  Returns zero on success, appropriate errorcode otherwise.
  */
-int processTopPattern(char* profileName,  Vector* topMarkerList, Vector* out_grepResultList, int profileExecCounter)
+int processTopPattern(char* profileName,  Vector* topMarkerList, int profileExecCounter)
 {
     T2Debug("%s ++in\n", __FUNCTION__);
-    if(profileName == NULL || topMarkerList == NULL || out_grepResultList == NULL)
+    if(profileName == NULL || topMarkerList == NULL)
     {
         T2Error("Invalid arguments for %s\n", __FUNCTION__);
         return -1;
@@ -241,14 +241,14 @@ int processTopPattern(char* profileName,  Vector* topMarkerList, Vector* out_gre
 
         if (strcmp(grepMarkerObj->markerName, "Load_Average") == 0)   // This block is for device level load average
         {
-            if (0 == getLoadAvg(out_grepResultList, grepMarkerObj->trimParam, grepMarkerObj->regexParam))
+            if (0 == getLoadAvg(grepMarkerObj, grepMarkerObj->trimParam, grepMarkerObj->regexParam))
             {
                 T2Debug("getLoadAvg() Failed with error");
             }
         }
         else
         {
-            getProcUsage(grepMarkerObj->searchString, out_grepResultList, grepMarkerObj->trimParam, grepMarkerObj->regexParam, filename);
+            getProcUsage(grepMarkerObj->searchString, grepMarkerObj, grepMarkerObj->trimParam, grepMarkerObj->regexParam, filename);
         }
 
     }
@@ -399,15 +399,16 @@ static inline void formatCount(char* buffer, size_t size, int count)
     snprintf(buffer, size, "%d", count);
 }
 
-static int getCountPatternMatch(FileDescriptor* fileDescriptor, const char* pattern)
+static int getCountPatternMatch(FileDescriptor* fileDescriptor, GrepMarker* marker)
 {
     T2Debug("%s ++in\n", __FUNCTION__);
-    if (!fileDescriptor || !fileDescriptor->cfaddr || !pattern || !*pattern || fileDescriptor->cf_map_size <= 0)
+    if (!fileDescriptor || !fileDescriptor->cfaddr || !marker || !marker->searchString || fileDescriptor->cf_map_size <= 0)
     {
         T2Error("Invalid file descriptor arguments pattern match\n");
         return -1; // Invalid arguments
     }
 
+    const char* pattern = marker->searchString;
     const char* buffer;
     size_t buflen = 0;
     size_t patlen = strlen(pattern);
@@ -457,20 +458,23 @@ static int getCountPatternMatch(FileDescriptor* fileDescriptor, const char* patt
         }
 
     }
-    T2Debug("count is %d\n", count);
+
+    // Using the union instead of the previous out list.
+    marker->u.count = count;
     T2Debug("%s --out\n", __FUNCTION__);
-    return count;
+    return 0;
 }
 
-static char* getAbsolutePatternMatch(FileDescriptor* fileDescriptor, const char* pattern)
+static int getAbsolutePatternMatch(FileDescriptor* fileDescriptor, GrepMarker* marker)
 {
     T2Debug("%s ++in\n", __FUNCTION__);
-    if (!fileDescriptor || !fileDescriptor->cfaddr || fileDescriptor->cf_map_size <= 0 || !pattern || !*pattern)
+    if (!fileDescriptor || !fileDescriptor->cfaddr || fileDescriptor->cf_map_size <= 0 || !marker || !marker->searchString)
     {
         T2Error("Invalid file descriptor arguments absolute\n");
-        return NULL;
+        return -1;
     }
 
+    const char* pattern = marker->searchString;
     const char* buffer;
     size_t buflen = 0;
     size_t patlen = strlen(pattern);
@@ -526,8 +530,10 @@ static char* getAbsolutePatternMatch(FileDescriptor* fileDescriptor, const char*
 
     if(!last_found)
     {
-        return NULL;
+        marker->u.markerValue = NULL;
+        return 0;
     }
+
     // Move pointer just after the pattern
     const char *start = last_found + patlen;
     size_t chars_left = buflen - (start - buffer);
@@ -539,15 +545,120 @@ static char* getAbsolutePatternMatch(FileDescriptor* fileDescriptor, const char*
     char *result = (char*)malloc(length + 1);
     if (!result)
     {
-        return NULL;
+        marker->u.markerValue = NULL;
+        return -1;
     }
     memcpy(result, start, length);
     result[length] = '\0';
+
+    marker->u.markerValue = result;
+    T2Debug("%s --out\n", __FUNCTION__);
+    return 0;
+}
+
+static int getAccumulatePatternMatch(FileDescriptor* fileDescriptor, GrepMarker* marker, Vector* out_grepResultList)
+{
+    T2Info("%s ++in", __FUNCTION__);
+    if (!fileDescriptor || !fileDescriptor->cfaddr || fileDescriptor->cf_file_size <= 0 || !marker || !marker->searchString || !*marker->searchString || !out_grepResultList)
+    {
+        T2Error("Invalid file descriptor arguments accumulate\n");
+        return -1;
+    }
+
+    const char* pattern = marker->searchString;
+    const char* buffer;
+    size_t buflen = 0;
+    size_t patlen = strlen(pattern);
+
+    // Using the existing accumulatedValues Vector from marker's union
+    Vector* accumulatedValues = marker->u.accumulatedValues;
+    if (!accumulatedValues)
+    {
+        T2Error("accumulatedValues vector is NULL in marker\n");
+        return -1;
+    }
+
+    for (int i = 0; i < 2; i++)
+    {
+        T2Info("%s %d \n", __FUNCTION__, __LINE__);
+        if (i == 0)
+        {
+            buffer = fileDescriptor->cfaddr;
+            buflen = (size_t)fileDescriptor->cf_file_size;
+        }
+        else
+        {
+            buffer = fileDescriptor->rfaddr;
+            buflen = (size_t)fileDescriptor->rf_file_size;
+        }
+
+        if (buffer == NULL)
+        {
+            T2Info("Invalid file descriptor arguments accumulate match\n");
+            continue;
+        }
+
+        const char *cur = buffer;
+        size_t bytes_left = buflen;
+
+        while (bytes_left >= patlen)
+        {
+            T2Info("%s %d \n", __FUNCTION__, __LINE__);
+            const char *found = strnstr(cur, pattern, bytes_left);
+            if (!found)
+            {
+                break;
+            }
+
+            // Move pointer just after the pattern
+            const char *start = found + patlen;
+            size_t chars_left = buflen - (start - buffer);
+
+            // Find next newline or end of buffer
+            const char *end = memchr(start, '\n', chars_left);
+            size_t length = end ? (size_t)(end - start) : chars_left;
+
+            // Create result string for this occurrence
+            char *result = (char*)malloc(length + 1);
+            if (result)
+            {
+                memcpy(result, start, length);
+                result[length] = '\0';
+                T2Info("%s %d : result = %s\n", __FUNCTION__, __LINE__, result);
+                Vector_PushBack(accumulatedValues, result);
+            }
+
+            size_t advance = (size_t)(found - cur) + patlen;
+            cur = found + patlen;
+            if (bytes_left < advance)
+            {
+                break;
+            }
+            bytes_left -= advance;
+        }
+        T2Info("%s %d --out\n", __FUNCTION__, __LINE__);
+    }
+
+    // Create individual GrepResult objects for each accumulated value
+    size_t accumulatedCount = Vector_Size(accumulatedValues);
+    for (size_t j = 0; j < accumulatedCount; j++)
+    {
+        char* value = (char*)Vector_At(accumulatedValues, j);
+        if (value)
+        {
+            GrepResult* result = createGrepResultObj(marker->markerName, value, marker->trimParam, marker->regexParam);
+            if (result)
+            {
+                Vector_PushBack(out_grepResultList, result);
+            }
+        }
+    }
+
     T2Debug("%s --out\n", __FUNCTION__);
-    return result;
+    return 0;
 }
 
-static int processPatternWithOptimizedFunction(const GrepMarker* marker, Vector* out_grepResultList, FileDescriptor* filedescriptor)
+static int processPatternWithOptimizedFunction(GrepMarker* marker, Vector* out_grepResultList, FileDescriptor* filedescriptor)
 {
     // Sanitize the input
     const char* memmmapped_data_cf = filedescriptor->cfaddr;
@@ -557,18 +668,18 @@ static int processPatternWithOptimizedFunction(const GrepMarker* marker, Vector*
         return -1;
     }
     // Extract the pattern and other parameters from the marker
-    const char* pattern = marker->searchString;
+    //const char* pattern = marker->searchString;
     bool trimParameter = marker->trimParam;
     char* regexParameter = marker->regexParam;
     char* header = marker->markerName;
     int count = 0;
-    char* last_found = NULL;
     MarkerType mType = marker->mType;
 
     if (mType == MTYPE_COUNTER)
     {
         // Count the number of occurrences of the pattern in the memory-mapped data
-        count = getCountPatternMatch(filedescriptor, pattern);
+        getCountPatternMatch(filedescriptor, marker);
+        count = marker->u.count;
         if (count > 0)
         {
             // If matches are found, process them accordingly
@@ -583,26 +694,32 @@ static int processPatternWithOptimizedFunction(const GrepMarker* marker, Vector*
             Vector_PushBack(out_grepResultList, result);
         }
     }
-    else
+    else if (mType == MTYPE_ACCUMULATE)
+    {
+        //Get MAX_ACCUMULATE number of occurrences of the pattern in the memory-mapped data
+        T2Info("%s %d : Accumulate is called\n", __FUNCTION__, __LINE__);
+        getAccumulatePatternMatch(filedescriptor, marker, out_grepResultList); //TO DO: Add limit of 20
+        T2Info("%s %d : Accumulate is complete\n", __FUNCTION__, __LINE__);
+    }
+    else /* MTYPE_ABSOLUTE */
     {
         // Get the last occurrence of the pattern in the memory-mapped data
-        last_found = getAbsolutePatternMatch(filedescriptor, pattern);
-        if (last_found)
+        getAbsolutePatternMatch(filedescriptor, marker);
+#if 0
+        if (marker->u.markerValue)
         {
             // If a match is found, process it accordingly
-            GrepResult* result = createGrepResultObj(header, last_found, trimParameter, regexParameter);
-            if(last_found)
-            {
-                free(last_found);
-                last_found = NULL;
-            }
+            GrepResult* result = createGrepResultObj(header, marker->u.markerValue, trimParameter, regexParameter);
+            free(marker->u.markerValue);
+            marker->u.markerValue = NULL;
             if (result == NULL)
             {
                 T2Error("Failed to create GrepResult\n");
                 return -1;
             }
             Vector_PushBack(out_grepResultList, result);
         }
+#endif
     }
     return 0;
 }
@@ -655,7 +772,7 @@ static int getLogFileDescriptor(GrepSeekProfile* gsProfile, const char* logPath,
     // Check if the file size matches the seek value from the map
     if (sb.st_size == seek_value_from_map)
     {
-        T2Debug("The logfile size matches the seek value (%ld) for %s\n", seek_value_from_map, logFile);
+        T2Info("The logfile size matches the seek value (%ld) for %s\n", seek_value_from_map, logFile);
         close(fd);
         return -1; // Consistent error return value
     }

source/dcautil/dca.h

@@ -31,6 +31,6 @@ int getDCAResultsInVector(GrepSeekProfile *gSeekProfile, Vector* vectorMarkerLis
 
 void T2InitProperties(); // declaration for initProperties
 
-int processTopPattern(char* profileName, Vector* topMarkerList, Vector* out_grepResultList, int execCount);
+int processTopPattern(char* profileName, Vector* topMarkerList, int execCount);
 
 #endif /* SRC_DCA_H_ */