Debian Codegraph @

tests/linux_kernel/helpers/test_ipc.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import contextlib
5 from pathlib import Path
6 import tempfile
7 import types
8
9 from drgn import NULL
10 from drgn.helpers.linux.ipc import (
11 decode_sysv_shm_flags,
12 find_sysv_msg_queue,
13 find_sysv_sem_array,
14 find_sysv_shm,
15 for_each_sysv_msg_queue,
16 for_each_sysv_sem_array,
17 for_each_sysv_shm,
18 )
19 from tests.linux_kernel import (
20 IPC_PRIVATE,
21 IPC_RMID,
22 SHM_LOCK,
23 LinuxKernelTestCase,
24 ftok,
25 msgctl,
26 msgget,
27 semctl,
28 semget,
29 shmctl,
30 shmget,
31 )
32
33 _PROC_SYSVIPC_PATH = Path("/proc/sysvipc")
34
35
36 @contextlib.contextmanager
37 def tmp_sysv_ipc():
38 try:
39 msg = []
40 sem = []
41 shm = []
42
43 with tempfile.NamedTemporaryFile() as tmp_file:
44 key = ftok(tmp_file.name, ord("m"))
45 msg.append((key, msgget(key)))
46
47 key = ftok(tmp_file.name, ord("e"))
48 sem.append((key, semget(key, nsems=4)))
49
50 key = ftok(tmp_file.name, ord("h"))
51 shm.append((key, shmget(key, size=64 * 1024)))
52
53 msg.append((IPC_PRIVATE, msgget(IPC_PRIVATE)))
54 sem.append((IPC_PRIVATE, semget(IPC_PRIVATE, nsems=4)))
55 shm.append((IPC_PRIVATE, shmget(IPC_PRIVATE, size=64 * 1024)))
56
57 shmctl(shm[0][1], SHM_LOCK)
58
59 yield types.SimpleNamespace(msg=msg, sem=sem, shm=shm)
60 finally:
61 for _, msqid in msg:
62 msgctl(msqid, IPC_RMID)
63 for _, semid in sem:
64 semctl(semid, 0, IPC_RMID)
65 for _, shmid in shm:
66 shmctl(shmid, IPC_RMID)
67
68
69 def parse_proc_sysvipc_key_and_id(name):
70 result = []
71 with (_PROC_SYSVIPC_PATH / name).open("r") as f:
72 f.readline() # Skip the header.
73 for line in f:
74 tokens = line.split()
75 result.append((int(tokens[0]), int(tokens[1])))
76 assert result
77 return result
78
79
80 class TestIpc(LinuxKernelTestCase):
81 @classmethod
82 def setUpClass(cls):
83 super().setUpClass()
84 cls.ipcs = cls.enterClassContext(tmp_sysv_ipc())
85
86 def test_for_each_sysv_msg_queue(self):
87 self.assertCountEqual(
88 [
89 (msg_queue.q_perm.key.value_(), msg_queue.q_perm.id.value_())
90 for msg_queue in for_each_sysv_msg_queue(self.prog)
91 ],
92 parse_proc_sysvipc_key_and_id("msg"),
93 )
94
95 def test_find_sysv_msg_queue(self):
96 key, id = self.ipcs.msg[0]
97 self.assertEqual(find_sysv_msg_queue(self.prog, id).q_perm.key, key)
98 self.assertIdentical(
99 find_sysv_msg_queue(self.prog, id ^ 0x40000000),
100 NULL(self.prog, "struct msg_queue *"),
101 )
102
103 def test_for_each_sysv_shm(self):
104 self.assertCountEqual(
105 [
106 (shm.shm_perm.key.value_(), shm.shm_perm.id.value_())
107 for shm in for_each_sysv_shm(self.prog)
108 ],
109 parse_proc_sysvipc_key_and_id("shm"),
110 )
111
112 def test_find_sysv_shm(self):
113 key, id = self.ipcs.shm[0]
114 self.assertEqual(find_sysv_shm(self.prog, id).shm_perm.key, key)
115 self.assertIdentical(
116 find_sysv_shm(self.prog, id ^ 0x40000000),
117 NULL(self.prog, "struct shmid_kernel *"),
118 )
119
120 def test_decode_sysv_shm_flags(self):
121 id = self.ipcs.shm[0][1]
122 self.assertEqual(
123 decode_sysv_shm_flags(find_sysv_shm(self.prog, id)), "SHM_LOCKED"
124 )
125
126 def test_for_each_sysv_sem_array(self):
127 self.assertCountEqual(
128 [
129 (sem_array.sem_perm.key.value_(), sem_array.sem_perm.id.value_())
130 for sem_array in for_each_sysv_sem_array(self.prog)
131 ],
132 parse_proc_sysvipc_key_and_id("sem"),
133 )
134
135 def test_find_sysv_sem_array(self):
136 key, id = self.ipcs.sem[0]
137 self.assertEqual(find_sysv_sem_array(self.prog, id).sem_perm.key, key)
138 self.assertIdentical(
139 find_sysv_sem_array(self.prog, id ^ 0x40000000),
140 NULL(self.prog, "struct sem_array *"),
141 )