LCOV - code coverage report
Current view: top level - lib/util - file.c (source / functions) Hit Total Coverage
Test: ut_cov_unit.info Lines: 20 69 29.0 %
Date: 2024-07-15 21:13:58 Functions: 2 5 40.0 %

          Line data    Source code
       1             : /*   SPDX-License-Identifier: BSD-3-Clause
       2             :  *   Copyright (C) 2015 Intel Corporation.
       3             :  *   All rights reserved.
       4             :  */
       5             : 
       6             : #include "spdk/file.h"
       7             : #include "spdk/string.h"
       8             : 
       9             : void *
      10           5 : spdk_posix_file_load(FILE *file, size_t *size)
      11             : {
      12           5 :         uint8_t *newbuf, *buf = NULL;
      13           5 :         size_t rc, buf_size, cur_size = 0;
      14             : 
      15           5 :         *size = 0;
      16           5 :         buf_size = 128 * 1024;
      17             : 
      18           5 :         while (buf_size <= 1024 * 1024 * 1024) {
      19           5 :                 newbuf = realloc(buf, buf_size);
      20           5 :                 if (newbuf == NULL) {
      21           0 :                         free(buf);
      22           0 :                         return NULL;
      23             :                 }
      24           5 :                 buf = newbuf;
      25             : 
      26           5 :                 rc = fread(buf + cur_size, 1, buf_size - cur_size, file);
      27           5 :                 cur_size += rc;
      28             : 
      29           5 :                 if (feof(file)) {
      30           5 :                         *size = cur_size;
      31           5 :                         return buf;
      32             :                 }
      33             : 
      34           0 :                 if (ferror(file)) {
      35           0 :                         free(buf);
      36           0 :                         return NULL;
      37             :                 }
      38             : 
      39           0 :                 buf_size *= 2;
      40             :         }
      41             : 
      42           0 :         free(buf);
      43           0 :         return NULL;
      44             : }
      45             : 
      46             : void *
      47           5 : spdk_posix_file_load_from_name(const char *file_name, size_t *size)
      48             : {
      49           5 :         FILE *file = fopen(file_name, "r");
      50             :         void *data;
      51             : 
      52           5 :         if (file == NULL) {
      53           0 :                 return NULL;
      54             :         }
      55             : 
      56           5 :         data = spdk_posix_file_load(file, size);
      57           5 :         fclose(file);
      58             : 
      59           5 :         return data;
      60             : }
      61             : 
      62             : static int
      63           0 : read_sysfs_attribute(char **attribute_p, const char *format, va_list args)
      64             : {
      65             :         char *attribute;
      66             :         FILE *file;
      67             :         char *path;
      68           0 :         size_t len = 0;
      69             :         ssize_t read;
      70             : 
      71           0 :         path = spdk_vsprintf_alloc(format, args);
      72           0 :         if (path == NULL) {
      73           0 :                 return -ENOMEM;
      74             :         }
      75             : 
      76           0 :         file = fopen(path, "r");
      77           0 :         free(path);
      78           0 :         if (file == NULL) {
      79           0 :                 return -errno;
      80             :         }
      81             : 
      82           0 :         *attribute_p = NULL;
      83           0 :         read = getline(attribute_p, &len, file);
      84           0 :         fclose(file);
      85           0 :         attribute = *attribute_p;
      86           0 :         if (read == -1) {
      87             :                 /* getline man page says line should be freed even on failure. */
      88           0 :                 free(attribute);
      89           0 :                 return -errno;
      90             :         }
      91             : 
      92             :         /* len is the length of the allocated buffer, which may be more than
      93             :          * the string's length. Reuse len to hold the actual strlen.
      94             :          */
      95           0 :         len = strlen(attribute);
      96           0 :         if (attribute[len - 1] == '\n') {
      97           0 :                 attribute[len - 1] = '\0';
      98             :         }
      99             : 
     100           0 :         return 0;
     101             : }
     102             : 
     103             : int
     104           0 : spdk_read_sysfs_attribute(char **attribute_p, const char *path_format, ...)
     105             : {
     106           0 :         va_list args;
     107             :         int rc;
     108             : 
     109           0 :         va_start(args, path_format);
     110           0 :         rc = read_sysfs_attribute(attribute_p, path_format, args);
     111           0 :         va_end(args);
     112             : 
     113           0 :         return rc;
     114             : }
     115             : 
     116             : int
     117           0 : spdk_read_sysfs_attribute_uint32(uint32_t *attribute, const char *path_format, ...)
     118             : {
     119           0 :         char *attribute_str = NULL;
     120             :         long long int val;
     121           0 :         va_list args;
     122             :         int rc;
     123             : 
     124           0 :         va_start(args, path_format);
     125           0 :         rc = read_sysfs_attribute(&attribute_str, path_format, args);
     126           0 :         va_end(args);
     127             : 
     128           0 :         if (rc != 0) {
     129           0 :                 return rc;
     130             :         }
     131             : 
     132           0 :         val = spdk_strtoll(attribute_str, 0);
     133           0 :         free(attribute_str);
     134           0 :         if (val < 0 || val > UINT32_MAX) {
     135           0 :                 return -EINVAL;
     136             :         }
     137             : 
     138           0 :         *attribute = (uint32_t)val;
     139           0 :         return 0;
     140             : }

Generated by: LCOV version 1.15