How to execute linux userspace application any no.of times in the linux target board?

The below code is used to test the uart driver on linux-jetson board which runs only one time,if needed to run multiple times on the board the device needs to be restarted.
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <termios.h>
#include <string.h>

#include <errno.h>
#include <limits.h>

#include <stdbool.h>
#include <unistd.h>

#define LOOPBACK_FORMAT "loopback: %s\r\n"
#define LOOPBACK_FORMAT_LEN strlen(LOOPBACK_FORMAT)
#define MAX_READ_SIZE 235
#define MAX_LOOPBACK_SIZE MAX_READ_SIZE + LOOPBACK_FORMAT_LEN

#define DEBUG

struct UartDevice {
char* filename;
int rate;

int fd;
struct termios *tty;
};

int uart_start(struct UartDevice* dev, bool canonical) {
struct termios *tty;
int fd;
int rc;

fd = open(dev->filename, O_RDWR | O_NOCTTY);
if (fd < 0) {
printf("%s: failed to open UART device\r\n", __func__);
return fd;
}

tty = malloc(sizeof(*tty));
if (!tty) {
printf("%s: failed to allocate UART TTY instance\r\n", __func__);

memset(tty, 0, sizeof(*tty));

/*
* Set baud-rate.
*/
tty->c_cflag |= dev->rate;

/* Ignore framing and parity errors in input. */
tty->c_iflag |= IGNPAR;

/* Use 8-bit characters. This too may affect standard streams,
* but any sane C library can deal with 8-bit characters. */
tty->c_cflag |= CS8;

/* Enable receiver. */
tty->c_cflag |= CREAD;

if (canonical) {
/* Enable canonical mode.
* This is the most important bit, as it enables line buffering etc. */
tty->c_lflag |= ICANON;
} else {
/* To maintain best compatibility with normal behaviour of terminals,
* we set TIME=0 and MAX=1 in noncanonical mode. This means that
* read() will block until at least one byte is available. */
tty->c_cc[VTIME] = 0;
tty->c_cc[VMIN] = 1;
}

/*
* Flush port.
*/
tcflush(fd, TCIFLUSH);

/*
* Apply attributes.
*/
rc = tcsetattr(fd, TCSANOW, tty);
if (rc) {
printf("%s: failed to set attributes\r\n", __func__);
return rc;
}

dev->fd = fd;
dev->tty = tty;

return 0;
}/*
* Read a string from the UART device.
*
* @param dev points to the UART device to be read from
* @param buf points to the start of buffer to be read into
* @param buf_len length of the buffer to be read
*
* @return - number of bytes read if the read procedure succeeded
* - negative if the read procedure failed
*/
int uart_reads(struct UartDevice* dev, char *buf, size_t buf_len) {
int rc;

rc = read(dev->fd, buf, buf_len - 1);
if (rc < 0) {
printf("%s: failed to read uart data\r\n", __func__);
return rc;
}

buf[rc] = '\0';
return rc;
}

/*
* Write data to the UART device.
*
* @param dev points to the UART device to be written to
* @param buf points to the start of buffer to be written from
* @param buf_len length of the buffer to be written
*
* @return - number of bytes written if the write procedure succeeded
* - negative if the write procedure failed
*/
int uart_writen(struct UartDevice* dev, char *buf, size_t buf_len) {
return write(dev->fd, buf, buf_len);
}

/*
* Write a string to the UART device.
*
* @param dev points to the UART device to be written to
* @param string points to the start of buffer to be written from
*
* @return - number of bytes written if the write procedure succeeded
* - negative if the write procedure failed
*/
int uart_writes(struct UartDevice* dev, char *string) {
size_t len = strlen(string);
return uart_writen(dev, string, len);
}

/*
* Stop the UART device.
*
* @param dev points to the UART device to be stopped
*/
void uart_stop(struct UartDevice* dev) {
close(dev->fd);
free(dev->tty);
}

int main()
{
struct UartDevice dev;
int rc;

dev.filename = "/dev/ttyTHS2";
dev.rate = B115200;

rc = uart_start(&dev, false);
if (rc) {
return rc;
}
char read_data[MAX_READ_SIZE];
char loopback_data[MAX_LOOPBACK_SIZE];
size_t read_data_len;

printf("UART DEMO\r\n");
uart_writes(&dev, "UART DEMO\r\n");

while (1)
{

read_data_len = uart_reads(&dev, read_data, MAX_READ_SIZE);

if (read_data_len > 0) {
printf("%s", read_data);
snprintf(loopback_data, MAX_LOOPBACK_SIZE, LOOPBACK_FORMAT, read_data);
uart_writes(&dev, loopback_data);
}

}

uart_stop(&dev);

return 0;
}

Could anyone please help me out what are the changes to be done to execute the above code infinite times?

Thanks and regards,
Imran patan,
India.