fix: proper support of vma mapping for restored posix semaphore

Signed-off-by: Brandon Smith <[email protected]>

Author: bsmithai

criu/files.c

@@ -1789,9 +1789,9 @@ static int collect_one_file(void *o, ProtobufCMessage *base, struct cr_img *i)
 	case FD_TYPES__PIDFD:
 		ret = collect_one_file_entry(fe, fe->pidfd->id, &fe->pidfd->base, &pidfd_cinfo);
 		break;
-    case FD_TYPES__POSIX_SEM:
-        ret = collect_one_file_entry(fe, fe->psm->fd_id, &fe->psm->base, &posix_sem_cinfo);
-        break;
+	case FD_TYPES__POSIX_SEM:
+		ret = collect_one_file_entry(fe, fe->psm->fd_id, &fe->psm->base, &posix_sem_cinfo);
+		break;
 #ifdef CONFIG_HAS_LIBBPF
 	case FD_TYPES__BPFMAP:
 		ret = collect_one_file_entry(fe, fe->bpf->id, &fe->bpf->base, &bpfmap_cinfo);
@@ -1817,8 +1817,5 @@ int prepare_files(void)
 	init_dead_pidfd_hash();
 	if (collect_image(&files_cinfo))
         return -1;
-    /* get posix semaphore info */
-    if (collect_image(&posix_sem_cinfo))
-        return -1;
     return 0;
 }

criu/include/files.h

@@ -207,5 +207,6 @@ extern struct collect_image_info posix_sem_cinfo;
 
 extern bool should_dump_posix_semaphore(const char *path, const struct fd_parms *parms);
 extern int try_dump_posix_semaphore(const char *path, int lfd, u32 id, const struct fd_parms *parms);
+extern int open_posix_sem_vma(int pid, struct vma_area *vma);
 
 #endif /* __CR_FILES_H__ */

criu/mem.c

@@ -32,6 +32,7 @@
 #include "prctl.h"
 #include "compel/infect-util.h"
 #include "pidfd-store.h"
+#include "files.h"
 
 #include "protobuf.h"
 #include "images/pagemap.pb-c.h"
@@ -765,7 +766,11 @@ int prepare_mm_pid(struct pstree_item *i)
 			ret = collect_filemap(vma);
 		else if (vma_area_is(vma, VMA_AREA_SOCKET))
 			ret = collect_socket_map(vma);
-		else
+		else if (vma_area_is(vma, VMA_AREA_POSIX_SEM)) {
+			/* Set up vm_open function for POSIX semaphore VMAs */
+			vma->vm_open = open_posix_sem_vma;
+			ret = 0;
+		} else
 			ret = 0;
 		if (ret)
 			break;

criu/pie/restorer.c

@@ -881,21 +881,46 @@ static unsigned long restore_mapping(VmaEntry *vma_entry)
 
     if (vma_entry_is(vma_entry, VMA_AREA_POSIX_SEM)) {
 		/*
-		 * POSIX semaphore VMA are handled by the POSIX semaphore
-		 * restore code which recreates the semaphore and maps it properly.
-		 * create an anonymous mapping as a placeholder.
+		 * POSIX semaphore VMAs need special handling.
+		 * The semaphore file should already exist from FD restoration.
+		 * If the VMA doesn't have an fd, we'll try to find semaphore files -> Same node
 		 */
-		pr_info("Restoring POSIX semaphore VMA at %" PRIx64 "-%" PRIx64 "\n", 
-				vma_entry->start, vma_entry->end);
+		void *addr;
+		int sem_fd = (int)vma_entry->fd;
 
-		flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED;
-		addr = sys_mmap(decode_pointer(vma_entry->start), vma_entry_len(vma_entry), 
-						prot | PROT_WRITE, flags, -1, 0);
+		pr_info("Restoring POSIX semaphore VMA at %" PRIx64 "-%" PRIx64 " (fd=%d)\n", 
+				vma_entry->start, vma_entry->end, sem_fd);
+		
+		if (sem_fd == -1) {
+		    return -1; // No semaphore file to restore	
+		}
+		
+		/* Map the semaphore file to the original VMA address */
+		addr = (void *)sys_mmap(decode_pointer(vma_entry->start), 
+						vma_entry_len(vma_entry),
+						vma_entry->prot, 
+						vma_entry->flags | MAP_FIXED, 
+						sem_fd, 
+						vma_entry->pgoff);
+		
+		if (addr == MAP_FAILED) {
+			pr_err("Failed to map semaphore VMA: %p (fd=%d)\n", addr, sem_fd);
+			return -1;
+		}
+		
+		if ((unsigned long)addr != vma_entry->start) {
+			pr_err("VMA mapping failed: expected %" PRIx64 ", got %lx\n", 
+				   vma_entry->start, (unsigned long)addr);
+			return -1;
+		}
+		
+		pr_info("Successfully mapped semaphore VMA %" PRIx64 "-%" PRIx64 " (fd=%d)\n",
+				vma_entry->start, vma_entry->end, sem_fd);
 
 		if ((vma_entry->fd != -1) && (vma_entry->status & VMA_CLOSE))
 			sys_close(vma_entry->fd);
 
-		return addr;
+		return vma_entry->start;
 	}
 
 	/*

criu/posix-sem.c

@@ -401,6 +401,7 @@ static int posix_sem_open(struct file_desc *d, int *new_fd)
 	sem_close(sem);
 
 	*new_fd = fd;
+	
 	pr_info("Successfully restored POSIX semaphore %s with fd %d (cross-host migration)\n", 
 			pse->name, fd);
 	return 0;
@@ -481,3 +482,45 @@ int try_dump_posix_semaphore(const char *path, int lfd, u32 id, const struct fd_
 		return -1;
 	}
 }
+
+/*
+ * Open POSIX semaphore for VMA mapping during restore
+ * This function is called during VMA preparation to assign the correct
+ * file descriptor to POSIX semaphore VMAs
+ */
+int open_posix_sem_vma(int pid, struct vma_area *vma)
+{
+	struct file_desc *fd_desc;
+	struct posix_sem_info *psi;
+	int sem_fd;
+	
+	pr_info("Opening POSIX semaphore VMA %" PRIx64 "-%" PRIx64 " (shmid=%" PRIx64 ")\n", 
+			vma->e->start, vma->e->end, vma->e->shmid);
+	
+	/* Find the POSIX semaphore file descriptor by shmid */
+	list_for_each_entry(psi, &posix_sem_list, d.fd_info_head) {
+		if (psi->pse->ino == vma->e->shmid) {
+			pr_info("Found matching POSIX semaphore %s for VMA (ino=%" PRIx64 ")\n", 
+					psi->pse->name, vma->e->shmid);
+			
+			fd_desc = &psi->d;
+			if (!inherited_fd(fd_desc, &sem_fd)) {
+				if (posix_sem_open(fd_desc, &sem_fd) < 0) {
+					pr_err("Failed to open POSIX semaphore %s\n", psi->pse->name);
+					return -1;
+				}
+			}
+			
+			pr_info("Assigned fd %d to POSIX semaphore VMA %" PRIx64 "-%" PRIx64 "\n", 
+					sem_fd, vma->e->start, vma->e->end);
+			
+			vma->e->fd = sem_fd;
+			vma->e->status |= VMA_CLOSE;
+			return 0;
+		}
+	}
+	
+	pr_err("No POSIX semaphore found for VMA %" PRIx64 "-%" PRIx64 " (shmid=%" PRIx64 ")\n", 
+		   vma->e->start, vma->e->end, vma->e->shmid);
+	return -1;
+}

criu/proc_parse.c

@@ -623,16 +623,18 @@ static int handle_vma(pid_t pid, struct vma_area *vma_area, const char *file_pat
 												 .mnt_id = vma_area->mnt_id,
 												 .fs_type = TMPFS_MAGIC
 											 }) == 1) {
-					pr_info("Skipping refular file processing for POSIX semaphore VMA\n");
+					pr_info("Skipping regular file processing for POSIX semaphore VMA\n");
 					close_safe(vm_file_fd);
 					vma_area->e->status = VMA_AREA_REGULAR | VMA_AREA_POSIX_SEM;
+					vma_area->e->shmid = vma_area->vmst->st_ino;
 					return 0;
 				} else {
 					pr_warn("Failed to handle as POSIX semaphore, continuing with regular file processing\n");
 				}
 			} else {
 				pr_info("POSIX semaphore VMA mapping for non-deleted semaphore: %s\n", file_path);
 				vma_area->e->status = VMA_AREA_REGULAR | VMA_AREA_POSIX_SEM;
+				vma_area->e->shmid = vma_area->vmst->st_ino;
 			}
 		} else {
             /* link remap would be needed for this case */