[mikhail@raspberrypi ~]$ sudo parted /dev/mmcblk0

[sudo] password for mikhail:

GNU Parted 3.5

Using /dev/mmcblk0

Welcome to GNU Parted! Type 'help' to view a list of commands.

(parted) print

Warning: Not all of the space available to /dev/mmcblk0 appears to be used, you can fix the GPT to use all of the space

(an extra 17208928 blocks) or continue with the current setting?

Fix/Ignore? f

Model: SD SC16G (sd/mmc)

Disk /dev/mmcblk0: 15.9GB

Sector size (logical/physical): 512B/512B

Partition Table: gpt

Disk Flags:

Number  Start   End     Size    File system  Name    Flags

 1      1049kB  269MB   268MB   fat32        bootfs  boot, esp

 2      269MB   7121MB  6851MB  ext4         rootfs

(parted) resizepart 2 15000

Warning: Partition /dev/mmcblk0p2 is being used. Are you sure you want to continue?

Yes/No? Y

(parted) q

Information: You may need to update /etc/fstab.

[mikhail@raspberrypi ~]$ sudo resize2fs /dev/mmcblk0p2

resize2fs 1.46.6 (1-Feb-2023)

Filesystem at /dev/mmcblk0p2 is mounted on /; on-line resizing required

old_desc_blocks = 1, new_desc_blocks = 2

The filesystem on /dev/mmcblk0p2 is now 3596317 (4k) blocks long.

3.1 Установите на компьютер ( x86 ) операционную систему РОСА Фреш 13. Дистрибутивы лежат вот здесь: https://rosa.ru/rosa-linux-download-links/

Я использовал сборку с графическим интерфейсом Plasma 6, но вы можете выбрать другой интерфейс по своему вкусу.

При разбиении диска убедитесь, что после установки у вас останется по 20 Гбайт свободного места в корневой файловой системе, в «/home» и в «/var/tmp».

Сразу после установки обновите систему.

3.2 Установите набор файлов конфигурации для создания образов операционной системы для различных платформ «image-builder». Качается вот отсюда, там же есть инструкция по установке необходимых ему пакетов:

https://github.com/rosalinux/image-builder

 3.3 Скопируйте файл /etc/pki/rpm-gpg/RPM-GPG-KEY-ROSA в каталог /usr/share/distribution-gpg-keys/

sudo cp /etc/pki/rpm-gpg/RPM-GPG-KEY-ROSA /usr/share/distribution-gpg-keys/

3.4 Перейдите в каталог image-builder-main/device/raspberry/rpi5

Для создания образа диска с установленной минимальной операционной системой версии 12.5.1 подставьте файл mkosi.conf вот отсюда: https://disk.360.yandex.ru/d/uj_4IyvKpfOxkQ

Для создания образа диска с установленной операционной системы версии 12.5.1 и графической оболочкой Plasma5 (впрочем, минимально наполненной) подставьте файл mkosi.conf вот отсюда: https://disk.360.yandex.ru/d/cPfQHdNrZpX82g

3.5 Запустите команду:

$ sudo mkosi --force

Во время сборки могут появляться отдельные незначительные ошибки, связанные с тем, что собирается предыдущая версия операционной системы, на которую скрипт не был изначально рассчитан. Но по окончании сборки образа вы должны увидеть сообщение вида:

‣  /home/mikhail/image-builder-main/device/raspberry/rpi5/rce.raw size is 6.5G, consumes 6.4G.

3.6. Необходимо отключить в свойствах файловой системы образа функцию orphan_file (она же FEATURE_C12).

Примонтируйте образ (файл raw) как устройство:

$ sudo losetup -P /dev/loop0 rosapi.raw

Убедитесь, что появились устройства для обоих разделов на образе диска:

$ lsblk

NAME      MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS

loop0       7:0    0     1G  0 loop

├─loop0p1 259:0    0   256M  0 part

└─loop0p2 259:1    0 815,9M  0 part

Отключите функцию orphan_file на большем (втором) разделе:

$ sudo tune2fs -O ^orphan_file /dev/loop0p2

tune2fs 1.47.2 (1-Jan-2025)

( tune2fs сделает работу молча, только напишет свою версию, да код возврата укажет на то, что она всё сделала успешно)

Размонтируйте образ диска:

$ sudo losetup -d /dev/loop0

// позаимствовано из https://twosixtech.com/blog/learning-libdrm/
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <drm.h>
#include <drm_mode.h>
#include <xf86drm.h>
#include <xf86drmMode.h>

char *device_path="/dev/dri/card0";

int main()
{
	int result=0;
	
	int fd = open(device_path, O_RDONLY);
    	if (fd < 0) 
	{
		printf ("Не удалось открыть файл %s на чтение\n", device_path);
        	return -1;
    	}

	drmModeRes *device = drmModeGetResources(fd);
    	if (!device) 
	{
		printf ("Не удался вызов drmModeGetResources\n");
        	result=-1;
        	goto close;
    	}
	// uint32_t
	printf ("Максимальные размеры: %lu %lu\n", device->max_width, device->max_height);



    // find first available connector
    printf("Checking for first available plugged-in connector.\n");
    drmModeConnector *first_available_connector;
    bool found_connector = false;
    for (int i = 0; i < device->count_connectors; i++) {
        first_available_connector = drmModeGetConnector(fd, device->connectors[i]);
        printf("%d\n", i);
        if (first_available_connector->connection == DRM_MODE_CONNECTED) {
            found_connector = true;
            break;
        } else {
            drmModeFreeConnector(first_available_connector);
        }
    }
    if(!found_connector) {
        fprintf(stderr, "Couldn't find plugged-in connector!\n");
        result=-1;
	goto close;
    }
    // find first available CRTC
    printf("Finding first available crtc\n");
    if(!device->count_crtcs) {
            fprintf(stderr, "No available CRTCs on first connector!");
            result=-1;
	    goto close;
        }
    // find first available mode
    printf("Checking for preferred mode.\n");
    drmModeModeInfo *mode;
    if(!first_available_connector->count_modes) {
            fprintf(stderr, "No available modes on first connector!");
            result=-1;
	    goto close;
        }
    bool found_preferred_mode = false;
    for (int i = 0; i < first_available_connector->count_modes; i++) {
        mode = &first_available_connector->modes[i];
        if (mode->type & DRM_MODE_TYPE_PREFERRED) {
            found_preferred_mode = true;
            break;
        }
    }
    if (!found_preferred_mode) {
        printf("Did not find preferred mode!\n");
	result=-1;
	goto close;
    }

	printf ("Предпочтительное разрешение: %u %u\n", mode->hdisplay, mode->vdisplay);
	

	
close:
	close(fd);
	return result;
}

QT += core gui widgets
TARGET = hello
TEMPLATE = app
SOURCES += main.cpp

#include <QApplication>
#include <QDialog>
#include <QLabel>
#include <QPushButton>
#include <QVBoxLayout>
#include <QHBoxLayout>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QDialog dialog;
    dialog.setWindowTitle("Miha");

    
    QLabel *logoLabel = new QLabel("Привет!");
    logoLabel->setAlignment(Qt::AlignCenter);
    logoLabel->setStyleSheet("font-size: 32px; font-weight: bold; color: #2c3e50;");

    
    QLabel *messageLabel = new QLabel("<font color=red>Hello, World!</font>");
    messageLabel->setAlignment(Qt::AlignCenter);

    
    QPushButton *okButton = new QPushButton("OK");
    QObject::connect(okButton, &QPushButton::clicked, &dialog, &QDialog::accept);

    
    QVBoxLayout *layout = new QVBoxLayout;
    layout->addWidget(logoLabel);
    layout->addWidget(messageLabel);
    layout->addWidget(okButton);
    layout->setAlignment(Qt::AlignCenter);

    dialog.setLayout(layout);
    dialog.resize(250, 150);

    dialog.show();
    return app.exec();
}

#include <gtk/gtk.h>

gint count = 0;
char buf[5];

void increase(GtkWidget *widget, gpointer label)
{
  count++;
  
  sprintf(buf, "%d", count);
  gtk_label_set_text(GTK_LABEL(label), buf);
}

void decrease(GtkWidget *widget, gpointer label)
{
  count--;
  
  sprintf(buf, "%d", count);
  gtk_label_set_text(GTK_LABEL(label), buf);
}

int main(int argc, char** argv) {

  setenv("GDK_DPI_SCALE","5",0);
  
  GtkWidget *label;
  GtkWidget *window;
  GtkWidget *plus;
  GtkWidget *minus;
  
  GtkWidget *grid;
  
  gtk_init(&argc, &argv);
  
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(window), 250, 500);
  gtk_window_set_title(GTK_WINDOW(window), "+-");
  

  grid = gtk_grid_new();



  plus = gtk_button_new_with_label("+");
  gtk_grid_attach(GTK_GRID(grid), plus, 0, 0, 1, 1); 
  gtk_widget_set_valign(window,GTK_ALIGN_FILL);



  minus = gtk_button_new_with_label("-");
  gtk_grid_attach(GTK_GRID(grid), minus, 0, 3, 1, 1); 

  label = gtk_label_new("0");
  gtk_grid_attach(GTK_GRID(grid), label, 2, 2, 1, 1); 

  gtk_container_add( GTK_CONTAINER(window), grid);

  gtk_widget_show_all(window);
  
  g_signal_connect(window, "destroy",
		   G_CALLBACK (gtk_main_quit), NULL);
  
  g_signal_connect(plus, "clicked", 
		   G_CALLBACK(increase), label);
  
  g_signal_connect(minus, "clicked", 
		   G_CALLBACK(decrease), label);

  
  gtk_main();
  
  return 0;
}

#include <gtk/gtk.h>

static void activate(GtkApplication *app, gpointer user_data) {

    // Добавлено в функцию activate():
GtkCssProvider *provider = gtk_css_provider_new();
const char *css = "button { min-height: 60px; min-width: 200px; font-size: 48px; }";
gtk_css_provider_load_from_data(provider, css, -1);
gtk_style_context_add_provider_for_display(
    gdk_display_get_default(),
    GTK_STYLE_PROVIDER(provider),
    GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
);

    // Создаем главное окно
    GtkWidget *window = gtk_application_window_new(app);
    gtk_window_set_title(GTK_WINDOW(window), "GTK4 Mobile App");
    
    
    // Создаем вертикальный контейнер
    GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
    gtk_widget_set_margin_top(box, 20);
    gtk_widget_set_margin_bottom(box, 20);
    gtk_widget_set_margin_start(box, 20);
    gtk_widget_set_margin_end(box, 20);
    
    // Создаем кнопки с увеличенными размерами
    GtkWidget *button1 = gtk_button_new_with_label("Кнопка 1");
    GtkWidget *button2 = gtk_button_new_with_label("Кнопка 2");
    
    // Устанавливаем минимальные размеры кнопок
    gtk_widget_set_size_request(button1, 200, 110);
    gtk_widget_set_size_request(button2, 200, 110);
    
    // Добавляем кнопки в контейнер
    gtk_box_append(GTK_BOX(box), button1);
    gtk_box_append(GTK_BOX(box), button2);
    
    // Добавляем контейнер в окно
    gtk_window_set_child(GTK_WINDOW(window), box);
    
    gtk_widget_show(window);
}

int main(int argc, char **argv) {
    // Создаем приложение
    GtkApplication *app = gtk_application_new("com.example.gtkapp", 
    //    G_APPLICATION_DEFAULT_FLAGS);
        0);
    
    g_signal_connect(app, "activate", G_CALLBACK(activate), NULL);
    
   
    int status = g_application_run(G_APPLICATION(app), argc, argv);
    g_object_unref(app);
    
    return status;
}

/*This source code copyrighted by Lazy Foo' Productions 2004-2024
and may not be redistributed without written permission.*/

//Using SDL, SDL_image, standard IO, and strings
#include <SDL.h>
#include <SDL_image.h>
#include <SDL_mixer.h>
#include <stdio.h>
#include <string>

//Screen dimension constants
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;

//Starts up SDL and creates window
bool init();

//Loads media
bool loadMedia();

//Frees media and shuts down SDL
void close();

//Loads individual image as texture
SDL_Texture* loadTexture( std::string path );

//The window we'll be rendering to
SDL_Window* gWindow = NULL;

//The sound effects that will be used
Mix_Chunk* gScratch = NULL;

//The window renderer
SDL_Renderer* gRenderer = NULL;

//Current displayed texture
SDL_Texture* gTexture = NULL;

bool init()
{
	//Initialization flag
	bool success = true;

	// Пробуем установить переменную окружения
	setenv("SDL_VIDEODRIVER","wayland",0);

	//Initialize SDL
	if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
	{
		printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
		success = false;
	}
	else
	{
			// Попробуем запретить текстовый ввод
			SDL_StopTextInput();

		//Set texture filtering to linear
		if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
		{
			printf( "Warning: Linear texture filtering not enabled!" );
		}

		//Create window
		gWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
		if( gWindow == NULL )
		{
			printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
			success = false;
		}
		else
		{

			//Create renderer for window
			gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED );
			if( gRenderer == NULL )
			{
				printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
				success = false;
			}
			else
			{
				//Initialize renderer color
				SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );

				//Initialize PNG loading
				int imgFlags = IMG_INIT_PNG;
				if( !( IMG_Init( imgFlags ) & imgFlags ) )
				{
					printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
					success = false;
				}

                		 //Initialize SDL_mixer
                		if( Mix_OpenAudio( 44100, MIX_DEFAULT_FORMAT, 2, 2048 ) < 0 )
                		{
                    			printf( "SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError() );
                   			 success = false;
                		}
			}
		}
	}

	return success;
}

bool loadMedia()
{
	//Loading success flag
	bool success = true;

	//Load PNG texture
	gTexture = loadTexture( "texture.png" );
	if( gTexture == NULL )
	{
		printf( "Failed to load texture image!\n" );
		success = false;
	}

	//Load sound effects
    	gScratch = Mix_LoadWAV( "scratch.wav" );
    	if( gScratch == NULL )
    	{
    	    printf( "Failed to load scratch sound effect! SDL_mixer Error: %s\n", Mix_GetError() );
    	    success = false;
    	}

	return success;
}

void close()
{
	//Free loaded image
	SDL_DestroyTexture( gTexture );
	gTexture = NULL;

    	//Free the sound effects
    	Mix_FreeChunk( gScratch );
    	gScratch = NULL;
    
	//Destroy window	
	SDL_DestroyRenderer( gRenderer );
	SDL_DestroyWindow( gWindow );
	gWindow = NULL;
	gRenderer = NULL;

	//Quit SDL subsystems
	IMG_Quit();
	SDL_Quit();
}

SDL_Texture* loadTexture( std::string path )
{
	//The final texture
	SDL_Texture* newTexture = NULL;

	//Load image at specified path
	SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
	if( loadedSurface == NULL )
	{
		printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
	}
	else
	{
		//Create texture from surface pixels
        newTexture = SDL_CreateTextureFromSurface( gRenderer, loadedSurface );
		if( newTexture == NULL )
		{
			printf( "Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
		}

		//Get rid of old loaded surface
		SDL_FreeSurface( loadedSurface );
	}

	return newTexture;
}

int main( int argc, char* args[] )
{
	//Start up SDL and create window
	if( !init() )
	{
		printf( "Failed to initialize!\n" );
	}
	else
	{
		//Load media
		if( !loadMedia() )
		{
			printf( "Failed to load media!\n" );
		}
		else
		{	
			//Main loop flag
			bool quit = false;

			//Event handler
			SDL_Event e;

			//While application is running
			while( !quit )
			{
				//Handle events on queue
				while( SDL_PollEvent( &e ) != 0 )
				{
					//User requests quit
					switch (e.type)
					{
					case  SDL_MOUSEBUTTONDOWN:
						Mix_PlayChannel( -1, gScratch, 0 );
						break;

					case SDL_QUIT:
						quit = true;
						break;
					}
				}

				//Clear screen
				SDL_RenderClear( gRenderer );

				//Render texture to screen
				SDL_RenderCopy( gRenderer, gTexture, NULL, NULL );

				//Update screen
				SDL_RenderPresent( gRenderer );
			}
		}
	}

	//Free resources and close SDL
	close();

	return 0;
}

Интересно, что работая на x86 и на ARM (она же aarch) версиях РОСА Хром, я не почувствовал никакой разницы. Даже странным показалось. Если раньше пересаживался, например, с PA-RISC на IBM Power, то приходилось переключаться на особенности их операционных систем. А здесь - ну прямо одно и то же.