Define sysfs max buffer size

sysfs_get_str() usages have inconsistant buffer size.
This results in wild buffer declarations and redundant memory usage.

Define maximum buffer size for sysfs strings.
Replace wild sysfs string buffer sizes for globaly defined value.

Signed-off-by: Mateusz Kusiak <mateusz.kusiak@intel.com>
Signed-off-by: Mariusz Tkaczyk <mariusz.tkaczyk@linux.intel.com>

diff --git a/Grow.c b/Grow.c
index 8fa978756a82909d32adac3fca6de308af295dac..8ca8ee781d1b4dd5f24c0ae717b7da64e5b519db 100644 (file)
--- a/Grow.c
+++ b/Grow.c
@@ -545,7 +545,7 @@ int Grow_consistency_policy(char *devname, int fd, struct context *c, struct sha
        char *subarray = NULL;
        int ret = 0;
        char container_dev[PATH_MAX];
-       char buf[20];
+       char buf[SYSFS_MAX_BUF_SIZE];
 
        if (s->consistency_policy != CONSISTENCY_POLICY_RESYNC &&
            s->consistency_policy != CONSISTENCY_POLICY_PPL) {
@@ -594,7 +594,7 @@ int Grow_consistency_policy(char *devname, int fd, struct context *c, struct sha
        }
 
        if (s->consistency_policy == CONSISTENCY_POLICY_PPL) {
-               if (sysfs_get_str(sra, NULL, "sync_action", buf, 20) <= 0) {
+               if (sysfs_get_str(sra, NULL, "sync_action", buf, sizeof(buf)) <= 0) {
                        ret = 1;
                        goto free_info;
                } else if (strcmp(buf, "reshape\n") == 0) {
@@ -817,12 +817,12 @@ static int freeze(struct supertype *st)
        else {
                struct mdinfo *sra = sysfs_read(-1, st->devnm, GET_VERSION);
                int err;
-               char buf[20];
+               char buf[SYSFS_MAX_BUF_SIZE];
 
                if (!sra)
                        return -1;
                /* Need to clear any 'read-auto' status */
-               if (sysfs_get_str(sra, NULL, "array_state", buf, 20) > 0 &&
+               if (sysfs_get_str(sra, NULL, "array_state", buf, sizeof(buf)) > 0 &&
                    strncmp(buf, "read-auto", 9) == 0)
                        sysfs_set_str(sra, NULL, "array_state", "clean");
 
@@ -838,10 +838,10 @@ static void unfreeze(struct supertype *st)
                return unfreeze_container(st);
        else {
                struct mdinfo *sra = sysfs_read(-1, st->devnm, GET_VERSION);
-               char buf[20];
+               char buf[SYSFS_MAX_BUF_SIZE];
 
                if (sra &&
-                   sysfs_get_str(sra, NULL, "sync_action", buf, 20) > 0 &&
+                   sysfs_get_str(sra, NULL, "sync_action", buf, sizeof(buf)) > 0 &&
                    strcmp(buf, "frozen\n") == 0)
                        sysfs_set_str(sra, NULL, "sync_action", "idle");
                sysfs_free(sra);
@@ -851,12 +851,12 @@ static void unfreeze(struct supertype *st)
 static void wait_reshape(struct mdinfo *sra)
 {
        int fd = sysfs_get_fd(sra, NULL, "sync_action");
-       char action[20];
+       char action[SYSFS_MAX_BUF_SIZE];
 
        if (fd < 0)
                return;
 
-       while (sysfs_fd_get_str(fd, action, 20) > 0 &&
+       while (sysfs_fd_get_str(fd, action, sizeof(action)) > 0 &&
               strncmp(action, "reshape", 7) == 0)
                sysfs_wait(fd, NULL);
        close(fd);
@@ -902,7 +902,7 @@ static int subarray_set_num(char *container, struct mdinfo *sra, char *name, int
         * to close a race with the array_state going clean before the
         * next write to raid_disks / stripe_cache_size
         */
-       char safe[50];
+       char safe[SYSFS_MAX_BUF_SIZE];
        int rc;
 
        /* only 'raid_disks' and 'stripe_cache_size' trigger md_allow_write */
@@ -2396,11 +2396,11 @@ release:
 static int verify_reshape_position(struct mdinfo *info, int level)
 {
        int ret_val = 0;
-       char buf[40];
+       char buf[SYSFS_MAX_BUF_SIZE];
        int rv;
 
        /* read sync_max, failure can mean raid0 array */
-       rv = sysfs_get_str(info, NULL, "sync_max", buf, 40);
+       rv = sysfs_get_str(info, NULL, "sync_max", buf, sizeof(buf));
 
        if (rv > 0) {
                char *ep;
@@ -3040,7 +3040,7 @@ static int reshape_array(char *container, int fd, char *devname,
        unsigned long long array_size;
        int done;
        struct mdinfo *sra = NULL;
-       char buf[20];
+       char buf[SYSFS_MAX_BUF_SIZE];
 
        /* when reshaping a RAID0, the component_size might be zero.
         * So try to fix that up.
@@ -3916,7 +3916,7 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
        unsigned long long array_size = (info->component_size
                                         * reshape->before.data_disks);
        int fd;
-       char buf[20];
+       char buf[SYSFS_MAX_BUF_SIZE];
 
        /* First, we unsuspend any region that is now known to be safe.
         * If suspend_point is on the 'wrong' side of reshape_progress, then
@@ -4094,8 +4094,8 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
                /* Check that sync_action is still 'reshape' to avoid
                 * waiting forever on a dead array
                 */
-               char action[20];
-               if (sysfs_get_str(info, NULL, "sync_action", action, 20) <= 0 ||
+               char action[SYSFS_MAX_BUF_SIZE];
+               if (sysfs_get_str(info, NULL, "sync_action", action, sizeof(action)) <= 0 ||
                    strncmp(action, "reshape", 7) != 0)
                        break;
                /* Some kernels reset 'sync_completed' to zero
@@ -4121,8 +4121,8 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
         */
        if (completed == 0) {
                unsigned long long reshapep;
-               char action[20];
-               if (sysfs_get_str(info, NULL, "sync_action", action, 20) > 0 &&
+               char action[SYSFS_MAX_BUF_SIZE];
+               if (sysfs_get_str(info, NULL, "sync_action", action, sizeof(action)) > 0 &&
                    strncmp(action, "idle", 4) == 0 &&
                    sysfs_get_ll(info, NULL,
                                 "reshape_position", &reshapep) == 0)
@@ -4240,7 +4240,7 @@ static int grow_backup(struct mdinfo *sra,
                        if (sd->disk.state & (1<<MD_DISK_FAULTY))
                                continue;
                        if (sd->disk.state & (1<<MD_DISK_SYNC)) {
-                               char sbuf[100];
+                               char sbuf[SYSFS_MAX_BUF_SIZE];
 
                                if (sysfs_get_str(sra, sd, "state",
                                                  sbuf, sizeof(sbuf)) < 0 ||

diff --git a/Incremental.c b/Incremental.c
index 3551c65ba753fdd85730067089c978a65c14e2a3..52e396237e64f54ef331e806bc9e845b849f7e59 100644 (file)
--- a/Incremental.c
+++ b/Incremental.c
@@ -1650,7 +1650,7 @@ int IncrementalRemove(char *devname, char *id_path, int verbose)
        struct mdstat_ent *ent;
        struct mddev_dev devlist;
        struct mdinfo mdi;
-       char buf[32];
+       char buf[SYSFS_MAX_BUF_SIZE];
 
        if (!id_path)
                dprintf("incremental removal without --path <id_path> lacks the possibility to re-add new device in this port\n");

diff --git a/Manage.c b/Manage.c
index 915322667788734b433cdaa4b1903a6ba2fa0377..d66dc7b8af91b7869baab96382e06f307a468dd8 100644 (file)
--- a/Manage.c
+++ b/Manage.c
@@ -181,7 +181,7 @@ int Manage_stop(char *devname, int fd, int verbose, int will_retry)
        char container[32];
        int err;
        int count;
-       char buf[32];
+       char buf[SYSFS_MAX_BUF_SIZE];
        unsigned long long rd1, rd2;
 
        if (will_retry && verbose == 0)
@@ -312,7 +312,7 @@ int Manage_stop(char *devname, int fd, int verbose, int will_retry)
        if (mdi && is_level456(mdi->array.level) &&
            sysfs_attribute_available(mdi, NULL, "sync_action") &&
            sysfs_attribute_available(mdi, NULL, "reshape_direction") &&
-           sysfs_get_str(mdi, NULL, "sync_action", buf, 20) > 0 &&
+           sysfs_get_str(mdi, NULL, "sync_action", buf, sizeof(buf)) > 0 &&
            strcmp(buf, "reshape\n") == 0 &&
            sysfs_get_two(mdi, NULL, "raid_disks", &rd1, &rd2) == 2) {
                unsigned long long position, curr;
@@ -1519,8 +1519,8 @@ int Manage_subdevs(char *devname, int fd,
                        sprintf(dname, "dev-%s", dv->devname);
                        sysfd = sysfs_open(fd2devnm(fd), dname, "block/dev");
                        if (sysfd >= 0) {
-                               char dn[20];
-                               if (sysfs_fd_get_str(sysfd, dn, 20) > 0 &&
+                               char dn[SYSFS_MAX_BUF_SIZE];
+                               if (sysfs_fd_get_str(sysfd, dn, sizeof(dn)) > 0 &&
                                    sscanf(dn, "%d:%d", &mj,&mn) == 2) {
                                        rdev = makedev(mj,mn);
                                        found = 1;

diff --git a/Monitor.c b/Monitor.c
index 9a1f2514534e81a7354e20430ba2ba2eace93fe3..824a69fc6b79e37aa19de7ccad0701089f2b66c9 100644 (file)
--- a/Monitor.c
+++ b/Monitor.c
@@ -1309,12 +1309,12 @@ int Wait(char *dev)
                         * sync_action does.
                         */
                        struct mdinfo mdi;
-                       char buf[21];
+                       char buf[SYSFS_MAX_BUF_SIZE];
 
                        if (sysfs_init(&mdi, -1, devnm))
                                return 2;
                        if (sysfs_get_str(&mdi, NULL, "sync_action",
-                                         buf, 20) > 0 &&
+                                         buf, sizeof(buf)) > 0 &&
                            strcmp(buf,"idle\n") != 0) {
                                e->percent = RESYNC_UNKNOWN;
                                if (strcmp(buf, "frozen\n") == 0) {
@@ -1393,7 +1393,7 @@ int WaitClean(char *dev, int verbose)
 
        if (rv) {
                int state_fd = sysfs_open(fd2devnm(fd), NULL, "array_state");
-               char buf[20];
+               char buf[SYSFS_MAX_BUF_SIZE];
                int delay = 5000;
 
                /* minimize the safe_mode_delay and prepare to wait up to 5s

diff --git a/managemon.c b/managemon.c
index a7bfa8f618a4d8efeba3e5592fe390e1cf85482c..358459e79435984196eec66661718a9181a0c9d0 100644 (file)
--- a/managemon.c
+++ b/managemon.c
@@ -454,7 +454,7 @@ static void manage_member(struct mdstat_ent *mdstat,
         * trying to find and assign a spare.
         * We do that whenever the monitor tells us too.
         */
-       char buf[64];
+       char buf[SYSFS_MAX_BUF_SIZE];
        int frozen;
        struct supertype *container = a->container;
        struct mdinfo *mdi;
@@ -664,7 +664,7 @@ static void manage_new(struct mdstat_ent *mdstat,
        struct mdinfo *mdi = NULL, *di;
        int i, inst;
        int failed = 0;
-       char buf[40];
+       char buf[SYSFS_MAX_BUF_SIZE];
 
        /* check if array is ready to be monitored */
        if (!mdstat->active || !mdstat->level)
@@ -738,7 +738,7 @@ static void manage_new(struct mdstat_ent *mdstat,
         * read this information for new arrays only (empty victim)
         */
        if ((victim == NULL) &&
-           (sysfs_get_str(mdi, NULL, "sync_action", buf, 40) > 0) &&
+           (sysfs_get_str(mdi, NULL, "sync_action", buf, sizeof(buf)) > 0) &&
            (strncmp(buf, "reshape", 7) == 0)) {
                if (sysfs_get_ll(mdi, NULL, "reshape_position",
                        &new->last_checkpoint) != 0)

diff --git a/mdadm.h b/mdadm.h
index 8dcd8b86f35a2dce98626d8a4f6dc3d5db267c89..46692730801e58ef7a6ce7c23b9c0f8ca7307b67 100644 (file)
--- a/mdadm.h
+++ b/mdadm.h
@@ -767,6 +767,8 @@ enum sysfs_read_flags {
        GET_DEVS_ALL    = (1 << 27),
 };
 
+#define SYSFS_MAX_BUF_SIZE 64
+
 /* If fd >= 0, get the array it is open on,
  * else use devnm.
  */

diff --git a/monitor.c b/monitor.c
index 820a93d0ceaf6aa6fc44618a14da3d3e136107c1..f54d07b24f591822df81135f731b1368d0c2350a 100644 (file)
--- a/monitor.c
+++ b/monitor.c
@@ -81,10 +81,10 @@ static int read_attr(char *buf, int len, int fd)
 
 static void read_resync_start(int fd, unsigned long long *v)
 {
-       char buf[30];
+       char buf[SYSFS_MAX_BUF_SIZE];
        int n;
 
-       n = read_attr(buf, 30, fd);
+       n = read_attr(buf, sizeof(buf), fd);
        if (n <= 0) {
                dprintf("Failed to read resync_start (%d)\n", fd);
                return;
@@ -98,11 +98,11 @@ static void read_resync_start(int fd, unsigned long long *v)
 static unsigned long long read_sync_completed(int fd)
 {
        unsigned long long val;
-       char buf[50];
+       char buf[SYSFS_MAX_BUF_SIZE];
        int n;
        char *ep;
 
-       n = read_attr(buf, 50, fd);
+       n = read_attr(buf, sizeof(buf), fd);
 
        if (n <= 0)
                return 0;
@@ -115,8 +115,8 @@ static unsigned long long read_sync_completed(int fd)
 
 static enum array_state read_state(int fd)
 {
-       char buf[20];
-       int n = read_attr(buf, 20, fd);
+       char buf[SYSFS_MAX_BUF_SIZE];
+       int n = read_attr(buf, sizeof(buf), fd);
 
        if (n <= 0)
                return bad_word;
@@ -125,8 +125,8 @@ static enum array_state read_state(int fd)
 
 static enum sync_action read_action( int fd)
 {
-       char buf[20];
-       int n = read_attr(buf, 20, fd);
+       char buf[SYSFS_MAX_BUF_SIZE];
+       int n = read_attr(buf, sizeof(buf), fd);
 
        if (n <= 0)
                return bad_action;
@@ -135,7 +135,7 @@ static enum sync_action read_action( int fd)
 
 int read_dev_state(int fd)
 {
-       char buf[100];
+       char buf[SYSFS_MAX_BUF_SIZE];
        int n = read_attr(buf, sizeof(buf), fd);
        char *cp;
        int rv = 0;
@@ -595,7 +595,7 @@ static int read_and_act(struct active_array *a, fd_set *fds)
                 */
                if ((a->curr_action != reshape) &&
                    (a->prev_action == reshape)) {
-                       char buf[40];
+                       char buf[SYSFS_MAX_BUF_SIZE];
                        if ((sysfs_get_str(&a->info, NULL,
                                          "reshape_position",
                                          buf,

diff --git a/msg.c b/msg.c
index 45cd45040a6126c22eb2bb2bfdf193cc7357790d..ba0e25be906d5b80de7a9f55ffd504e23accc876 100644 (file)
--- a/msg.c
+++ b/msg.c
@@ -324,7 +324,7 @@ int block_monitor(char *container, const int freeze)
 {
        struct mdstat_ent *ent, *e, *e2;
        struct mdinfo *sra = NULL;
-       char buf[64];
+       char buf[SYSFS_MAX_BUF_SIZE];
        int rv = 0;
 
        if (check_mdmon_version(container))
@@ -366,7 +366,7 @@ int block_monitor(char *container, const int freeze)
                     !sysfs_attribute_available(sra, NULL, "sync_action")) ||
                    (freeze &&
                     sysfs_attribute_available(sra, NULL, "sync_action") &&
-                    sysfs_get_str(sra, NULL, "sync_action", buf, 20) > 0 &&
+                    sysfs_get_str(sra, NULL, "sync_action", buf, sizeof(buf)) > 0 &&
                     strcmp(buf, "frozen\n") == 0))
                        /* pass */;
                else {

diff --git a/super-intel.c b/super-intel.c
index efac07d59c53b58d73105a8acbe431be2be2e02e..c3e832686578a03d2f20a1aed09019a39946d9a5 100644 (file)
--- a/super-intel.c
+++ b/super-intel.c
@@ -11156,11 +11156,11 @@ int recover_backup_imsm(struct supertype *st, struct mdinfo *info)
        unsigned int sector_size = super->sector_size;
        unsigned long long curr_migr_unit = current_migr_unit(migr_rec);
        unsigned long long num_migr_units = get_num_migr_units(migr_rec);
-       char buffer[20];
+       char buffer[SYSFS_MAX_BUF_SIZE];
        int skipped_disks = 0;
        struct dl *dl_disk;
 
-       err = sysfs_get_str(info, NULL, "array_state", (char *)buffer, 20);
+       err = sysfs_get_str(info, NULL, "array_state", (char *)buffer, sizeof(buffer));
        if (err < 1)
                return 1;
 
@@ -12079,9 +12079,9 @@ exit_imsm_reshape_super:
 static int read_completed(int fd, unsigned long long *val)
 {
        int ret;
-       char buf[50];
+       char buf[SYSFS_MAX_BUF_SIZE];
 
-       ret = sysfs_fd_get_str(fd, buf, 50);
+       ret = sysfs_fd_get_str(fd, buf, sizeof(buf));
        if (ret < 0)
                return ret;
 
@@ -12154,12 +12154,12 @@ int wait_for_reshape_imsm(struct mdinfo *sra, int ndata)
 
        do {
                int rc;
-               char action[20];
+               char action[SYSFS_MAX_BUF_SIZE];
                int timeout = 3000;
 
                sysfs_wait(fd, &timeout);
                if (sysfs_get_str(sra, NULL, "sync_action",
-                                 action, 20) > 0 &&
+                                 action, sizeof(action)) > 0 &&
                                strncmp(action, "reshape", 7) != 0) {
                        if (strncmp(action, "idle", 4) == 0)
                                break;
@@ -12206,7 +12206,7 @@ int check_degradation_change(struct mdinfo *info,
                        if (sd->disk.state & (1<<MD_DISK_FAULTY))
                                continue;
                        if (sd->disk.state & (1<<MD_DISK_SYNC)) {
-                               char sbuf[100];
+                               char sbuf[SYSFS_MAX_BUF_SIZE];
                                int raid_disk = sd->disk.raid_disk;
 
                                if (sysfs_get_str(info,

diff --git a/sysfs.c b/sysfs.c
index decb02b8d80f08b2c7e7f3e409c64e094c283472..0dc7badfc4b721ccebae1e7db688dca753141401 100644 (file)
--- a/sysfs.c
+++ b/sysfs.c
@@ -664,7 +664,7 @@ int sysfs_set_array(struct mdinfo *info, int vers)
        ver[0] = 0;
        if (info->array.major_version == -1 &&
            info->array.minor_version == -2) {
-               char buf[1024];
+               char buf[SYSFS_MAX_BUF_SIZE];
 
                strcat(strcpy(ver, "external:"), info->text_version);
 
@@ -675,7 +675,7 @@ int sysfs_set_array(struct mdinfo *info, int vers)
                 * version first, and preserve the flag
                 */
                if (sysfs_get_str(info, NULL, "metadata_version",
-                                 buf, 1024) > 0)
+                                 buf, sizeof(buf)) > 0)
                        if (strlen(buf) >= 9 && buf[9] == '-')
                                ver[9] = '-';
 
@@ -900,11 +900,11 @@ int sysfs_freeze_array(struct mdinfo *sra)
         * return 0 if this kernel doesn't support 'frozen'
         * return 1 if it worked.
         */
-       char buf[20];
+       char buf[SYSFS_MAX_BUF_SIZE];
 
        if (!sysfs_attribute_available(sra, NULL, "sync_action"))
                return 1; /* no sync_action == frozen */
-       if (sysfs_get_str(sra, NULL, "sync_action", buf, 20) <= 0)
+       if (sysfs_get_str(sra, NULL, "sync_action", buf, sizeof(buf)) <= 0)
                return 0;
        if (strcmp(buf, "frozen\n") == 0)
                /* Already frozen */