How to properly disable Linux deep C-States from a C program?

On Linux OS CPUs run on different power-saving states called the C-states. They are ranging from C0 to Cn. C0 is the state with maximum performance, but consume more power. So to maximize performance one can disable transition to deeper states. This can be done by writing 0 to the /dev/cpu_dma_latency file.
See: https://www.quora.com/What-is-the-purpose-of-dev-cpu_dma_latency-device-file-on-Linux-systems

The problem is that there is two way of writing to the file.

1. Write the number 0.

    FILE *fp;  
   
    void start_low_latency()
    {  
        char target = '0';  
   
        fp= fopen("/dev/cpu_dma_latency", "r+");  
        if (fp == NULL)
        {  
           fprintf(stderr, "Failed to open PM QOS file: %s", strerror(errno));  
           exit(errno);  
        }  
   
        fputc(target, fp);  
      }  
   
    void stop_low_latency()
    { 
        if (fp != NULL)//if (fp == NULL)
          fclose(fp);
    }
   

Reference: https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux_for_real_time/8/html/optimizing_rhel_8_for_real_time_for_low_latency_operation/assembly_controlling-power-management-transitions_optimizing-rhel8-for-real-time-for-low-latency-operation

2. Binary write of the number 0.

    static int laptop = 0;
    static int latency_target_fd = -1;
    static int32_t latency_target_value = 0;  
   
    static void start_low_latency()//static void set_latency_target()
    {
        struct stat s;
        int err;  
   
        if (laptop) {
            warn("not setting cpu_dma_latency to save battery power\n");
            return;
        }  
   
        errno = 0;
        err = stat("/dev/cpu_dma_latency", &s);  
   
        if (err == -1) {
            err_msg_n(errno, "WARN: stat /dev/cpu_dma_latency failed");
            return;
        }
   
        errno = 0;
        latency_target_fd = open("/dev/cpu_dma_latency", O_RDWR);  
   
        if (latency_target_fd == -1) {
            err_msg_n(errno, "WARN: open /dev/cpu_dma_latency");
            return;
        }  
   
        errno = 0;
        err = write(latency_target_fd, &latency_target_value, 4);  
   
        if (err < 1) {
            err_msg_n(errno, "# error setting cpu_dma_latency to %d!", latency_target_value);
            close(latency_target_fd);
            return;
        }
        printf("# /dev/cpu_dma_latency set to %dus\n", latency_target_value);
    }
   
    static void stop_low_latency()
    {
        if (latency_target_fd >= 0)
            close(latency_target_fd);
    }
   

Reference: https://kernel.googlesource.com/pub/scm/utils/rt-tests/rt-tests/+/stable/devel/v1.0.1/src/cyclictest/cyclictest.c

Which method is the right one?

According to the kernel documentation,

> To register the default PM QoS target for the CPU latency QoS, the
> process must open /dev/cpu_dma_latency.
>
> As long as the device node is held open that process has a registered
> request on the parameter.
>
> To change the requested target value, the process needs to write an
> s32 value to the open device node. Alternatively, it can write a hex
> string for the value using the 10 char long format e.g. "0x12345678".
> This translates to a cpu_latency_qos_update_request() call.
>
> To remove the user mode request for a target value simply close the
> device node.

Note well that there are two alternatives for how to express the requested C-state value:

• write a 32-bit integer, OR
• write a hex string

For the latter case, the docs do specify a 10-char format, but it is entirely plausible that the implementation also accepts shorter hex strings. In that case, these alternatives each cover one of your cases, meaning both are acceptable.