[PROTO] string size limitation

column          limit         description
File path       4K or ByFile  either in function argument or as protocol value
Shader sources  4K or ByFile  glGetShaderSource and glGetShaderiv probes
Http contents   1024 bytes
string type
arguments       256 bytes     there is not any case of string type yet

Change-Id: I4c5a940ae7f7d4831d41d226e701fd548cfa1777
Signed-off-by: Vitaliy Cherepanov <v.cherepanov@samsung.com>

diff --git a/include/binproto.h b/include/binproto.h
index 362c9c7842715468e50cf5ec6b8147aba404b93c..ddaf3947784b558d7b7e783bdea979105e0a36b7 100644 (file)
--- a/include/binproto.h
+++ b/include/binproto.h
@@ -68,6 +68,13 @@
 
 #define SCREENSHOT_DIRECTORY   "/tmp/da"
 
+#define MAX_PACK_FILENAME_LEN (4 * 1024)
+#define MAX_SHADER_LEN (4 * 1024)
+#define ADD_LOCAL_BUF_SIZE (1024)
+#define MAX_GL_CONTEXT_VALUE_SIZE (1024)
+#define MAX_LOCAL_BUF_SIZE (MAX_SHADER_LEN + ADD_LOCAL_BUF_SIZE)
+#define LOCAL_BUF msg_buf
+
 // TODO: remove this copy-paste
 #define CALLER_ADDRESS                                                 \
        ((void*) __builtin_extract_return_addr(__builtin_return_address(0)))
@@ -162,9 +169,34 @@ static char *pack_array(char *to, va_list *args, uint32_t element_size)
        return to;
 }
 
-static char __attribute__((used)) *pack_value_by_type(char *to, const char t, va_list *args)
+static char __attribute__((used)) *pack_string_to_file(char *to, const char *st,
+                                                      uint32_t data_len,
+                                                      uint32_t max_len)
+{
+       if (data_len < max_len) {
+               /* pack string to buffer */
+               to = pack_string(to, st);
+       } else {
+               /* pack string to file */
+               char template_name[] = SCREENSHOT_DIRECTORY "/swap_XXXXXX";
+               char dst_path_pack[MAX_PATH_LENGTH];
+               FILE *file;
+               mktemp(template_name);
+               file = fopen(template_name, "w");
+               if (file != NULL) {
+                       fwrite(st, data_len, 1, file);
+                       fclose(file);
+               }
+               sprintf(dst_path_pack, "FILE:%s", template_name);
+               to = pack_string(to, dst_path_pack);
+       }
+       return to;
+}
+
+static char __attribute__((used)) *pack_value_by_type(char *to, const char **t, va_list *args)
 {
        uint8_t c;
+       uint8_t cs;
        uint32_t d;
        uint64_t x;
        uint64_t p;
@@ -173,9 +205,9 @@ static char __attribute__((used)) *pack_value_by_type(char *to, const char t, va
        char *s;
        int n;
 
-       *to++ = t;
+       *to++ = **t;
 
-       switch (t) {
+       switch (**t) {
        case 'c':
                c = (uint8_t)va_arg(*args, uint32_t);
                memcpy(to, &c, sizeof(c));
@@ -209,10 +241,31 @@ static char __attribute__((used)) *pack_value_by_type(char *to, const char t, va
                to += sizeof(w);
                break;
        case 's':
+               cs = *((*t)+1);
                s = va_arg(*args, char *);
-               n = strlen(s) + 1;
-               strncpy(to, s, n);
-               to += n;
+
+               switch (cs) {
+                       case '4': //"s4" - pack 4K or to file
+                               (*t)++;
+                               to = pack_string_to_file(to, s, strlen(s),
+                                                        MAX_PACK_FILENAME_LEN);
+                               break;
+                       case '0': //"s0" - pack 256 bytes
+                               (*t)++;
+                               n = strlen(s) + 1;
+                               if (n >= 255)
+                                       n = 255;
+                               strncpy(to, s, n);
+                               to[n-1] = '\0';
+                               to += n;
+                               break;
+                       default: //"s" - pack all string
+                               n = strlen(s) + 1;
+                               strncpy(to, s, n);
+                               to += n;
+                               break;
+               }
+
                break;
        case 'v':
        case 'n':
@@ -230,31 +283,39 @@ static char __attribute__((used)) *pack_value_by_type(char *to, const char t, va
                /* array of 'w' double */
                to = pack_array(to, args, sizeof(w));
                break;
-       default:
+       default: {
+               char buf[128];
+               sprintf(buf, "ERROR PACK #%d '%c'!!!", **t, **t);
+               PRINTERR(buf);
                to--;
                break;
+               }
        }
 
+       (*t)++;
        return to;
 }
 
 static char __attribute__((used)) *pack_args(char *to, const char *fmt, ...)
 {
        va_list args;
-       uint32_t num = strlen(fmt);
+       uint32_t num = 0;
        const char *t = fmt;
+       char *size_p = to;
 
-       if(*t == '\0') {
-               num = 0;
-       }
-
+       //put dummy num value
        memcpy(to, &num, sizeof(num));
        to += sizeof(num);
 
        va_start(args, fmt);
 
-       for (t = fmt; *t != '\0'; t++)
-               to = pack_value_by_type(to, *t, &args);
+       for (t = fmt; *t != '\0';) {
+               to = pack_value_by_type(to, &t, &args);
+               num++;
+       }
+
+       //set real num value
+       memcpy(size_p, &num, sizeof(num));
 
        va_end(args);
 
@@ -264,9 +325,11 @@ static char __attribute__((used)) *pack_args(char *to, const char *fmt, ...)
 static char __attribute__((used)) *pack_ret(char *to, char ret_type, ...)
 {
        va_list args;
+       char fmt[] = {ret_type, 0};
+       const char *fmtp = (const char *)fmt;
 
        va_start(args, ret_type);
-       to = pack_value_by_type(to, ret_type, &args);
+       to = pack_value_by_type(to, &fmtp, &args);
        va_end(args);
 
        return to;
@@ -351,7 +414,9 @@ static char __attribute__((used)) *pack_ret(char *to, char ret_type, ...)
                BUF_PTR = pack_int64(BUF_PTR, fd_value);                \
                BUF_PTR = pack_int32(BUF_PTR, fd_api_type);             \
                BUF_PTR = pack_int64(BUF_PTR, file_size);               \
-               BUF_PTR = pack_string(BUF_PTR, file_path);              \
+               BUF_PTR = pack_string_to_file(BUF_PTR, file_path,       \
+                                             strlen(file_path),        \
+                                             MAX_PACK_FILENAME_LEN);   \
        } while (0)
 
 #define PACK_SCREENSHOT(image_file_path, orientation)                          \
@@ -425,13 +490,6 @@ static char __attribute__((used)) *pack_ret(char *to, char ret_type, ...)
                BUF_PTR = pack_int32(BUF_PTR, api_type);             \
        } while (0)
 
-
-#define MAX_SHADER_LEN (4 * 1024)
-#define ADD_LOCAL_BUF_SIZE (1024)
-#define MAX_GL_CONTEXT_VALUE_SIZE (1024)
-#define MAX_LOCAL_BUF_SIZE (MAX_SHADER_LEN + ADD_LOCAL_BUF_SIZE)
-#define LOCAL_BUF msg_buf
-
 #define PREPARE_LOCAL_BUF()                    \
                char LOCAL_BUF[MAX_LOCAL_BUF_SIZE];             \
                char *BUF_PTR = LOCAL_BUF;                      \

diff --git a/probe_file/da_io_posix.c b/probe_file/da_io_posix.c
index 9c45e6df7d9fa30e711e71d79ea0329dd0c95be9..68aa65bbb50e04e9199f03898ab3bed4f2b1d746 100755 (executable)
--- a/probe_file/da_io_posix.c
+++ b/probe_file/da_io_posix.c
@@ -73,8 +73,9 @@ int open(const char* path, int oflag, ...)
 
        ret = openp(path, oflag, mode);
 
-       AFTER_PACK_ORIGINAL_FD(API_ID_open, 'd', ret, 0, ret, FD_API_OPEN, "sdd",
-                              absolutize_filepath(buffer, path), oflag, mode);
+       AFTER_PACK_ORIGINAL_FD(API_ID_open, 'd', ret, 0, ret, FD_API_OPEN,
+                              "s4dd", absolutize_filepath(buffer, path), oflag,
+                              mode);
 
        return ret;
 }
@@ -99,7 +100,7 @@ int openat(int fd, const char* path, int oflag, ...)
        ret = openatp(fd, path, oflag, mode);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_openat, 'd', ret, 0, ret, FD_API_OPEN,
-                              "dsdd", fd, absolutize_filepath(buffer, path),
+                              "ds4dd", fd, absolutize_filepath(buffer, path),
                               oflag, mode);
 
        return ret;
@@ -115,8 +116,8 @@ int creat(const char* path, mode_t mode)
 
        ret = creatp(path, mode);
 
-       AFTER_PACK_ORIGINAL_FD(API_ID_creat, 'd', ret, 0, ret, FD_API_OPEN, "sd",
-                              absolutize_filepath(buffer, path), mode);
+       AFTER_PACK_ORIGINAL_FD(API_ID_creat, 'd', ret, 0, ret, FD_API_OPEN,
+                              "s4d", absolutize_filepath(buffer, path), mode);
 
        return ret;
 }

diff --git a/probe_file/da_io_stdc.c b/probe_file/da_io_stdc.c
index 550fe8f3abfcfb2f74435b9d9dfcb992742c2d06..a8be001889ebc12743003d9a072a4c7f46ecb00f 100644 (file)
--- a/probe_file/da_io_stdc.c
+++ b/probe_file/da_io_stdc.c
@@ -58,7 +58,7 @@ FILE* fopen(const char* filename, const char* mode)
        fret = fopenp(filename, mode);
 
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fopen,
-                                 'p', fret, 0, fret, FD_API_OPEN, "ss",
+                                 'p', fret, 0, fret, FD_API_OPEN, "s4s",
                                  absolutize_filepath(buffer, filename), mode);
 
        return fret;
@@ -77,7 +77,7 @@ FILE* freopen(const char * filename, const char * mode, FILE * stream)
        fret = freopenp(filename, mode, stream);
 
        AFTER_PACK_ORIGINAL_FILEP(API_ID_freopen, 'p', fret, 0, fret, FD_API_OPEN,
-                                 "ssp", absolutize_filepath(buffer, filename),
+                                 "s4sp", absolutize_filepath(buffer, filename),
                                  mode, voidp_to_uint64(stream));
 
        return fret;

diff --git a/probe_graphics/da_gles20.h b/probe_graphics/da_gles20.h
index 0f0010f8ce04fadd4344da8686704a31298635b8..a789e223ec3e6f518ebc17f936fd0b10d1f8e1cb 100644 (file)
--- a/probe_graphics/da_gles20.h
+++ b/probe_graphics/da_gles20.h
@@ -65,25 +65,11 @@
 #define PACK_GL_SHADER(GL_api_type, GL_elapsed_time, GL_shader, GL_shader_size)        \
        do {    /* PACK_GL_SHADER */                                            \
                PACK_GL_ADD_COMMON(GL_api_type, GL_elapsed_time);               \
-               if ( (GL_shader_size <= MAX_SHADER_LEN) &&                      \
-                    (GL_shader_size <= (sizeof(LOCAL_BUF) - (BUF_PTR - LOCAL_BUF)))) {\
-                       /* pack shaders to buffer */                            \
-                       BUF_PTR = pack_string(BUF_PTR, GL_shader);              \
-               } else {                                                        \
-                       /* pack shaders to file */                              \
-                       char dst_path[MAX_PATH_LENGTH];                         \
-                       char dst_path_pack[MAX_PATH_LENGTH];                    \
-                       FILE *file;                                             \
-                       sprintf(dst_path, SCREENSHOT_DIRECTORY "/%d_%d.shd",    \
-                               getpid(), probeInfo.eventIndex);                \
-                       file = fopen(dst_path, "w");                            \
-                       if (file != NULL) {                                     \
-                               fwrite(GL_shader, GL_shader_size, 1, file);     \
-                               fclose(file);                                   \
-                       }                                                       \
-                       sprintf(dst_path_pack, "FILE:%s", dst_path);            \
-                       BUF_PTR = pack_string(BUF_PTR, dst_path_pack);          \
-               }                                                               \
+               uint32_t min = (sizeof(LOCAL_BUF) - (BUF_PTR - LOCAL_BUF));     \
+               if (min > MAX_SHADER_LEN)                                       \
+                       min = MAX_SHADER_LEN;                                   \
+               BUF_PTR = pack_string_to_file(BUF_PTR, GL_shader,               \
+                                             GL_shader_size, min);             \
        } while (0)
 
 #define BEFORE(FUNCNAME)                                               \

diff --git a/probe_socket/da_socket.h b/probe_socket/da_socket.h
index 6dff8b4298eba0a5621d43f591269896fa2b255d..3f6817bb32d3aa0bada3bf4f56827cc38ce25cc7 100644 (file)
--- a/probe_socket/da_socket.h
+++ b/probe_socket/da_socket.h
@@ -124,7 +124,8 @@
                BUF_PTR = pack_int32(BUF_PTR, TOTAL_INFO.host_ip);              \
                BUF_PTR = pack_int32(BUF_PTR, TOTAL_INFO.host_port);            \
                BUF_PTR = pack_int64(BUF_PTR, TOTAL_INFO.msg_total_size);       \
-               BUF_PTR = pack_bin(BUF_PTR, TOTAL_INFO.msg_buf, TOTAL_INFO.msg_pack_size);                      \
+               BUF_PTR = pack_bin(BUF_PTR, TOTAL_INFO.msg_buf,                 \
+                                  TOTAL_INFO.msg_pack_size);                   \
        } while (0)
 
 

diff --git a/probe_tizenapi/tizen_file.cpp b/probe_tizenapi/tizen_file.cpp
index 078b5f751df120d89d5f0242760802bbb8351755..4372c8145a5637a2acb9598a38bac3539acadae0 100755 (executable)
--- a/probe_tizenapi/tizen_file.cpp
+++ b/probe_tizenapi/tizen_file.cpp
@@ -94,7 +94,7 @@ result File::Construct(const Tizen::Base::String& filePath,
 
                PREPARE_LOCAL_BUF();
                PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_Tizen__Base__String__openMode__bool_createParentDirectories_,
-                                 "ssd", absolutize_filepath(buffer,temp_path),
+                                 "s4sd", absolutize_filepath(buffer,temp_path),
                                  temp_mode, createParentDirectories);
                PACK_COMMON_END('x', ret, ret, blockresult);
                PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp_path);
@@ -160,7 +160,8 @@ result File::Construct(const Tizen::Base::String& filePath,
                PREPARE_LOCAL_BUF();
                PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
                                  API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_Tizen__Base__String__openMode_,
-                                 "ss", absolutize_filepath(buffer, temp_path), temp_mode);
+                                 "s4s", absolutize_filepath(buffer, temp_path),
+                                 temp_mode);
                PACK_COMMON_END('x', ret, ret, blockresult);
                PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp_path);
                FLUSH_LOCAL_BUF();
@@ -220,7 +221,7 @@ result File::Construct(const Tizen::Base::String& filePath,
                PREPARE_LOCAL_BUF();
                PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
                                  API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_char__pOpenMode_,
-                                 "sp", absolutize_filepath(buffer, temp),
+                                 "s4p", absolutize_filepath(buffer, temp),
                                  voidp_to_uint64(pOpenMode));
                PACK_COMMON_END('x', ret, ret, blockresult);
                PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp);