Raspberry PI uint8_t alignment

Question

I got this kind of problem with using uint8_t as array which is passed to my transferring function. At the moment of passing from main function to transfer it changes size to 4 elements. Same thing with array which I create inside my transfer function, even though I manually create another array to send my values with passed length from main function. I understand it is because of data alignment and padding on my processor. Is there any way to solve it? Or I'm printing it wrong.

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

#define ARRAY_SIZE(a)  (sizeof(a) / sizeof(uint8_t))

static const char *device = "/dev/spidev0.0";
static uint8_t mode;
static uint8_t bits = 8;
static uint32_t speed = 1000000;
static uint16_t delay;


static void transfer(int fd, const uint8_t *pass, size_t arsize)
{
int ret,i,k;
printf(" rozmiar tabpass=%d ", arsize);
uint8_t *rx = (uint8_t*) malloc(arsize * sizeof(uint8_t)); 
//this is where I create rx with arsize lenght
uint8_t *tx = (uint8_t*) malloc(arsize * sizeof(uint8_t));
for (i = 0; i < arsize; i++){
    *(rx + i) = 0;
    *(tx + i) = *(pass + i);
}
for (k = 0; k < (sizeof (pass) / sizeof (pass[0])); k++) {
    printf(" a%X\n ", pass[k]); 
//here I check length of passed array
}
for (k = 0; k < (sizeof (tx) / sizeof (tx[0])); k++) {
    printf(" b%X\n ", tx[k]); 
// I check length of newly created array, should be equal to array size
}
printf(" rozmiar tabtx=%d ", ARRAY_SIZE(tx));
struct spi_ioc_transfer tr = {
    .tx_buf = (unsigned long)tx,
    .rx_buf = (unsigned long)rx,
    .len = arsize,
    .delay_usecs = delay,
    .speed_hz = speed,
    .bits_per_word = bits,
    .cs_change = 0,
};

ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
printf(" rozmiar tabrx=%d ", ARRAY_SIZE(rx)); 
//here it prints size of array equals 4
for (ret = 0; ret < arsize; ret++) {
    if (!(ret % 6))
        puts("");

    printf("%d. %.2X ", ret, rx[ret]);

}
puts("");
tr.cs_change = 1;
}

int main(int argc, char *argv[])
{
int ret = 0;
int fd;

fd = open(device, O_RDWR);

/*
* spi mode
*/
ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);

ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);

/*
* bits per word
*/
ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);

ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);

/*
* max speed hz
*/
ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);

ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);

printf("spi mode: %d\n", mode);
printf("bits per word: %d\n", bits);
printf("max speed: %d Hz (%d KHz)\n", speed, speed / 1000);

uint8_t tx1[] = {
    0x0, 0x1b, 0xa5
};
transfer(fd, tx1, ARRAY_SIZE(tx1));

uint8_t tx2[] = {
    0x0, 0x33, 0x30
};
printf(" %d. ", ARRAY_SIZE(tx2));
transfer(fd, tx2, ARRAY_SIZE(tx2));

uint8_t tx3[] = {
    0x0, 0x52, 0x90
};
transfer(fd, tx3, ARRAY_SIZE(tx3));

uint8_t tx4[] = {
    0x80, 0x60
};
printf(" %d. ", ARRAY_SIZE(tx4));
transfer(fd, tx4, ARRAY_SIZE(tx4));

close(fd);

return ret;
}

Answer 1

For the sizeof operator to give the actual size of the array, you need to:

1. Allocate the array statically
2. Refer to the array within its scope of declaration

For example:

void func()
{
    int arr[10];
    int total_size = sizeof(arr);
    int num_of_elements = sizeof(arr)/sizeof(*arr);
    ...
}

An example of when the array is not statically allocated:

void func()
{
    int* arr = malloc(sizeof(int)*10);
    int total_size = sizeof(arr); // will give you the size of 'int*'
    ...
}

An example of when the array is not within its scope of declaration:

void func(int arr[]) // same as 'int* arr'
{
    int total_size = sizeof(arr); // will give you the size of 'int*'
    ...
}