]> Git Repo - linux.git/blob - tools/testing/selftests/exec/non-regular.c
scsi: zfcp: Trace when request remove fails after qdio send fails
[linux.git] / tools / testing / selftests / exec / non-regular.c
1 // SPDX-License-Identifier: GPL-2.0+
2 #include <errno.h>
3 #include <fcntl.h>
4 #include <stdio.h>
5 #include <string.h>
6 #include <unistd.h>
7 #include <sys/socket.h>
8 #include <sys/stat.h>
9 #include <sys/sysmacros.h>
10 #include <sys/types.h>
11
12 #include "../kselftest_harness.h"
13
14 /* Remove a file, ignoring the result if it didn't exist. */
15 void rm(struct __test_metadata *_metadata, const char *pathname,
16         int is_dir)
17 {
18         int rc;
19
20         if (is_dir)
21                 rc = rmdir(pathname);
22         else
23                 rc = unlink(pathname);
24
25         if (rc < 0) {
26                 ASSERT_EQ(errno, ENOENT) {
27                         TH_LOG("Not ENOENT: %s", pathname);
28                 }
29         } else {
30                 ASSERT_EQ(rc, 0) {
31                         TH_LOG("Failed to remove: %s", pathname);
32                 }
33         }
34 }
35
36 FIXTURE(file) {
37         char *pathname;
38         int is_dir;
39 };
40
41 FIXTURE_VARIANT(file)
42 {
43         const char *name;
44         int expected;
45         int is_dir;
46         void (*setup)(struct __test_metadata *_metadata,
47                       FIXTURE_DATA(file) *self,
48                       const FIXTURE_VARIANT(file) *variant);
49         int major, minor, mode; /* for mknod() */
50 };
51
52 void setup_link(struct __test_metadata *_metadata,
53                 FIXTURE_DATA(file) *self,
54                 const FIXTURE_VARIANT(file) *variant)
55 {
56         const char * const paths[] = {
57                 "/bin/true",
58                 "/usr/bin/true",
59         };
60         int i;
61
62         for (i = 0; i < ARRAY_SIZE(paths); i++) {
63                 if (access(paths[i], X_OK) == 0) {
64                         ASSERT_EQ(symlink(paths[i], self->pathname), 0);
65                         return;
66                 }
67         }
68         ASSERT_EQ(1, 0) {
69                 TH_LOG("Could not find viable 'true' binary");
70         }
71 }
72
73 FIXTURE_VARIANT_ADD(file, S_IFLNK)
74 {
75         .name = "S_IFLNK",
76         .expected = ELOOP,
77         .setup = setup_link,
78 };
79
80 void setup_dir(struct __test_metadata *_metadata,
81                FIXTURE_DATA(file) *self,
82                const FIXTURE_VARIANT(file) *variant)
83 {
84         ASSERT_EQ(mkdir(self->pathname, 0755), 0);
85 }
86
87 FIXTURE_VARIANT_ADD(file, S_IFDIR)
88 {
89         .name = "S_IFDIR",
90         .is_dir = 1,
91         .expected = EACCES,
92         .setup = setup_dir,
93 };
94
95 void setup_node(struct __test_metadata *_metadata,
96                 FIXTURE_DATA(file) *self,
97                 const FIXTURE_VARIANT(file) *variant)
98 {
99         dev_t dev;
100         int rc;
101
102         dev = makedev(variant->major, variant->minor);
103         rc = mknod(self->pathname, 0755 | variant->mode, dev);
104         ASSERT_EQ(rc, 0) {
105                 if (errno == EPERM)
106                         SKIP(return, "Please run as root; cannot mknod(%s)",
107                                 variant->name);
108         }
109 }
110
111 FIXTURE_VARIANT_ADD(file, S_IFBLK)
112 {
113         .name = "S_IFBLK",
114         .expected = EACCES,
115         .setup = setup_node,
116         /* /dev/loop0 */
117         .major = 7,
118         .minor = 0,
119         .mode = S_IFBLK,
120 };
121
122 FIXTURE_VARIANT_ADD(file, S_IFCHR)
123 {
124         .name = "S_IFCHR",
125         .expected = EACCES,
126         .setup = setup_node,
127         /* /dev/zero */
128         .major = 1,
129         .minor = 5,
130         .mode = S_IFCHR,
131 };
132
133 void setup_fifo(struct __test_metadata *_metadata,
134                 FIXTURE_DATA(file) *self,
135                 const FIXTURE_VARIANT(file) *variant)
136 {
137         ASSERT_EQ(mkfifo(self->pathname, 0755), 0);
138 }
139
140 FIXTURE_VARIANT_ADD(file, S_IFIFO)
141 {
142         .name = "S_IFIFO",
143         .expected = EACCES,
144         .setup = setup_fifo,
145 };
146
147 FIXTURE_SETUP(file)
148 {
149         ASSERT_GT(asprintf(&self->pathname, "%s.test", variant->name), 6);
150         self->is_dir = variant->is_dir;
151
152         rm(_metadata, self->pathname, variant->is_dir);
153         variant->setup(_metadata, self, variant);
154 }
155
156 FIXTURE_TEARDOWN(file)
157 {
158         rm(_metadata, self->pathname, self->is_dir);
159 }
160
161 TEST_F(file, exec_errno)
162 {
163         char * const argv[2] = { (char * const)self->pathname, NULL };
164
165         EXPECT_LT(execv(argv[0], argv), 0);
166         EXPECT_EQ(errno, variant->expected);
167 }
168
169 /* S_IFSOCK */
170 FIXTURE(sock)
171 {
172         int fd;
173 };
174
175 FIXTURE_SETUP(sock)
176 {
177         self->fd = socket(AF_INET, SOCK_STREAM, 0);
178         ASSERT_GE(self->fd, 0);
179 }
180
181 FIXTURE_TEARDOWN(sock)
182 {
183         if (self->fd >= 0)
184                 ASSERT_EQ(close(self->fd), 0);
185 }
186
187 TEST_F(sock, exec_errno)
188 {
189         char * const argv[2] = { " magic socket ", NULL };
190         char * const envp[1] = { NULL };
191
192         EXPECT_LT(fexecve(self->fd, argv, envp), 0);
193         EXPECT_EQ(errno, EACCES);
194 }
195
196 TEST_HARNESS_MAIN
This page took 0.045539 seconds and 4 git commands to generate.