Commit | Line | Data |
---|---|---|
108ffa8c | 1 | /* |
1adfd609 | 2 | * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
1da177e4 LT |
3 | * Licensed under the GPL |
4 | */ | |
5 | ||
6 | #include <stdio.h> | |
7 | #include <unistd.h> | |
8 | #include <errno.h> | |
9 | #include <fcntl.h> | |
10 | #include <signal.h> | |
1da177e4 LT |
11 | #include <sys/ioctl.h> |
12 | #include <sys/mount.h> | |
1adfd609 JD |
13 | #include <sys/socket.h> |
14 | #include <sys/stat.h> | |
15 | #include <sys/un.h> | |
8eeba4e9 | 16 | #include <sys/types.h> |
37185b33 | 17 | #include <os.h> |
1da177e4 | 18 | |
c9a3072d | 19 | static void copy_stat(struct uml_stat *dst, const struct stat64 *src) |
1da177e4 LT |
20 | { |
21 | *dst = ((struct uml_stat) { | |
22 | .ust_dev = src->st_dev, /* device */ | |
23 | .ust_ino = src->st_ino, /* inode */ | |
24 | .ust_mode = src->st_mode, /* protection */ | |
25 | .ust_nlink = src->st_nlink, /* number of hard links */ | |
26 | .ust_uid = src->st_uid, /* user ID of owner */ | |
27 | .ust_gid = src->st_gid, /* group ID of owner */ | |
28 | .ust_size = src->st_size, /* total size, in bytes */ | |
29 | .ust_blksize = src->st_blksize, /* blocksize for filesys I/O */ | |
30 | .ust_blocks = src->st_blocks, /* number of blocks allocated */ | |
31 | .ust_atime = src->st_atime, /* time of last access */ | |
32 | .ust_mtime = src->st_mtime, /* time of last modification */ | |
33 | .ust_ctime = src->st_ctime, /* time of last change */ | |
34 | }); | |
35 | } | |
36 | ||
37 | int os_stat_fd(const int fd, struct uml_stat *ubuf) | |
38 | { | |
39 | struct stat64 sbuf; | |
40 | int err; | |
41 | ||
9ead6fee | 42 | CATCH_EINTR(err = fstat64(fd, &sbuf)); |
1adfd609 | 43 | if (err < 0) |
108ffa8c | 44 | return -errno; |
1da177e4 | 45 | |
1adfd609 | 46 | if (ubuf != NULL) |
1da177e4 | 47 | copy_stat(ubuf, &sbuf); |
108ffa8c | 48 | return err; |
1da177e4 LT |
49 | } |
50 | ||
51 | int os_stat_file(const char *file_name, struct uml_stat *ubuf) | |
52 | { | |
53 | struct stat64 sbuf; | |
54 | int err; | |
55 | ||
1adfd609 JD |
56 | CATCH_EINTR(err = stat64(file_name, &sbuf)); |
57 | if (err < 0) | |
108ffa8c | 58 | return -errno; |
1da177e4 | 59 | |
1adfd609 | 60 | if (ubuf != NULL) |
1da177e4 | 61 | copy_stat(ubuf, &sbuf); |
108ffa8c | 62 | return err; |
1da177e4 LT |
63 | } |
64 | ||
1adfd609 | 65 | int os_access(const char *file, int mode) |
1da177e4 LT |
66 | { |
67 | int amode, err; | |
68 | ||
1adfd609 JD |
69 | amode = (mode & OS_ACC_R_OK ? R_OK : 0) | |
70 | (mode & OS_ACC_W_OK ? W_OK : 0) | | |
71 | (mode & OS_ACC_X_OK ? X_OK : 0) | | |
72 | (mode & OS_ACC_F_OK ? F_OK : 0); | |
1da177e4 LT |
73 | |
74 | err = access(file, amode); | |
1adfd609 | 75 | if (err < 0) |
108ffa8c | 76 | return -errno; |
1da177e4 | 77 | |
108ffa8c | 78 | return 0; |
1da177e4 LT |
79 | } |
80 | ||
1da177e4 LT |
81 | /* FIXME? required only by hostaudio (because it passes ioctls verbatim) */ |
82 | int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg) | |
83 | { | |
84 | int err; | |
85 | ||
86 | err = ioctl(fd, cmd, arg); | |
1adfd609 | 87 | if (err < 0) |
108ffa8c | 88 | return -errno; |
1da177e4 | 89 | |
108ffa8c | 90 | return err; |
1da177e4 LT |
91 | } |
92 | ||
1da177e4 LT |
93 | /* FIXME: ensure namebuf in os_get_if_name is big enough */ |
94 | int os_get_ifname(int fd, char* namebuf) | |
95 | { | |
1adfd609 | 96 | if (ioctl(fd, SIOCGIFNAME, namebuf) < 0) |
108ffa8c | 97 | return -errno; |
1da177e4 | 98 | |
108ffa8c | 99 | return 0; |
1da177e4 LT |
100 | } |
101 | ||
102 | int os_set_slip(int fd) | |
103 | { | |
104 | int disc, sencap; | |
105 | ||
106 | disc = N_SLIP; | |
1adfd609 | 107 | if (ioctl(fd, TIOCSETD, &disc) < 0) |
b4fd310e | 108 | return -errno; |
1da177e4 LT |
109 | |
110 | sencap = 0; | |
1adfd609 | 111 | if (ioctl(fd, SIOCSIFENCAP, &sencap) < 0) |
b4fd310e | 112 | return -errno; |
1da177e4 | 113 | |
108ffa8c | 114 | return 0; |
1da177e4 LT |
115 | } |
116 | ||
1da177e4 LT |
117 | int os_mode_fd(int fd, int mode) |
118 | { | |
119 | int err; | |
120 | ||
1adfd609 JD |
121 | CATCH_EINTR(err = fchmod(fd, mode)); |
122 | if (err < 0) | |
108ffa8c | 123 | return -errno; |
1da177e4 | 124 | |
108ffa8c | 125 | return 0; |
1da177e4 LT |
126 | } |
127 | ||
128 | int os_file_type(char *file) | |
129 | { | |
130 | struct uml_stat buf; | |
131 | int err; | |
132 | ||
133 | err = os_stat_file(file, &buf); | |
1adfd609 | 134 | if (err < 0) |
108ffa8c | 135 | return err; |
1da177e4 | 136 | |
1adfd609 | 137 | if (S_ISDIR(buf.ust_mode)) |
108ffa8c | 138 | return OS_TYPE_DIR; |
1adfd609 | 139 | else if (S_ISLNK(buf.ust_mode)) |
108ffa8c | 140 | return OS_TYPE_SYMLINK; |
1adfd609 | 141 | else if (S_ISCHR(buf.ust_mode)) |
108ffa8c | 142 | return OS_TYPE_CHARDEV; |
1adfd609 | 143 | else if (S_ISBLK(buf.ust_mode)) |
108ffa8c | 144 | return OS_TYPE_BLOCKDEV; |
1adfd609 | 145 | else if (S_ISFIFO(buf.ust_mode)) |
108ffa8c | 146 | return OS_TYPE_FIFO; |
1adfd609 | 147 | else if (S_ISSOCK(buf.ust_mode)) |
108ffa8c JD |
148 | return OS_TYPE_SOCK; |
149 | else return OS_TYPE_FILE; | |
1da177e4 LT |
150 | } |
151 | ||
c9a3072d | 152 | int os_file_mode(const char *file, struct openflags *mode_out) |
1da177e4 LT |
153 | { |
154 | int err; | |
155 | ||
156 | *mode_out = OPENFLAGS(); | |
157 | ||
512b6fb1 | 158 | err = access(file, W_OK); |
1adfd609 | 159 | if (err && (errno != EACCES)) |
512b6fb1 | 160 | return -errno; |
1adfd609 | 161 | else if (!err) |
512b6fb1 | 162 | *mode_out = of_write(*mode_out); |
1da177e4 | 163 | |
512b6fb1 | 164 | err = access(file, R_OK); |
1adfd609 | 165 | if (err && (errno != EACCES)) |
512b6fb1 | 166 | return -errno; |
1adfd609 | 167 | else if (!err) |
512b6fb1 | 168 | *mode_out = of_read(*mode_out); |
1da177e4 | 169 | |
512b6fb1 | 170 | return err; |
1da177e4 LT |
171 | } |
172 | ||
c9a3072d | 173 | int os_open_file(const char *file, struct openflags flags, int mode) |
1da177e4 | 174 | { |
b4fd310e | 175 | int fd, err, f = 0; |
1da177e4 | 176 | |
1adfd609 JD |
177 | if (flags.r && flags.w) |
178 | f = O_RDWR; | |
179 | else if (flags.r) | |
180 | f = O_RDONLY; | |
181 | else if (flags.w) | |
182 | f = O_WRONLY; | |
1da177e4 LT |
183 | else f = 0; |
184 | ||
1adfd609 JD |
185 | if (flags.s) |
186 | f |= O_SYNC; | |
187 | if (flags.c) | |
188 | f |= O_CREAT; | |
189 | if (flags.t) | |
190 | f |= O_TRUNC; | |
191 | if (flags.e) | |
192 | f |= O_EXCL; | |
bf53d85e JD |
193 | if (flags.a) |
194 | f |= O_APPEND; | |
1da177e4 LT |
195 | |
196 | fd = open64(file, f, mode); | |
1adfd609 | 197 | if (fd < 0) |
512b6fb1 | 198 | return -errno; |
1da177e4 | 199 | |
1adfd609 | 200 | if (flags.cl && fcntl(fd, F_SETFD, 1)) { |
b4fd310e | 201 | err = -errno; |
512b6fb1 | 202 | close(fd); |
b4fd310e | 203 | return err; |
1da177e4 LT |
204 | } |
205 | ||
512b6fb1 | 206 | return fd; |
1da177e4 LT |
207 | } |
208 | ||
c9a3072d | 209 | int os_connect_socket(const char *name) |
1da177e4 LT |
210 | { |
211 | struct sockaddr_un sock; | |
212 | int fd, err; | |
213 | ||
214 | sock.sun_family = AF_UNIX; | |
215 | snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name); | |
216 | ||
217 | fd = socket(AF_UNIX, SOCK_STREAM, 0); | |
1adfd609 | 218 | if (fd < 0) { |
dc1561ac PBG |
219 | err = -errno; |
220 | goto out; | |
221 | } | |
1da177e4 LT |
222 | |
223 | err = connect(fd, (struct sockaddr *) &sock, sizeof(sock)); | |
1adfd609 | 224 | if (err) { |
dc1561ac PBG |
225 | err = -errno; |
226 | goto out_close; | |
227 | } | |
1da177e4 | 228 | |
dc1561ac PBG |
229 | return fd; |
230 | ||
231 | out_close: | |
232 | close(fd); | |
233 | out: | |
234 | return err; | |
1da177e4 LT |
235 | } |
236 | ||
237 | void os_close_file(int fd) | |
238 | { | |
239 | close(fd); | |
240 | } | |
0565103d AI |
241 | int os_fsync_file(int fd) |
242 | { | |
243 | if (fsync(fd) < 0) | |
244 | return -errno; | |
245 | return 0; | |
246 | } | |
1da177e4 | 247 | |
ba180fd4 | 248 | int os_seek_file(int fd, unsigned long long offset) |
1da177e4 | 249 | { |
ba180fd4 | 250 | unsigned long long actual; |
1da177e4 LT |
251 | |
252 | actual = lseek64(fd, offset, SEEK_SET); | |
1adfd609 | 253 | if (actual != offset) |
108ffa8c JD |
254 | return -errno; |
255 | return 0; | |
1da177e4 LT |
256 | } |
257 | ||
1da177e4 | 258 | int os_read_file(int fd, void *buf, int len) |
3d564047 JD |
259 | { |
260 | int n = read(fd, buf, len); | |
261 | ||
1adfd609 | 262 | if (n < 0) |
3d564047 JD |
263 | return -errno; |
264 | return n; | |
265 | } | |
266 | ||
1da177e4 | 267 | int os_write_file(int fd, const void *buf, int len) |
3d564047 JD |
268 | { |
269 | int n = write(fd, (void *) buf, len); | |
270 | ||
1adfd609 | 271 | if (n < 0) |
3d564047 JD |
272 | return -errno; |
273 | return n; | |
274 | } | |
275 | ||
805f11a0 RW |
276 | int os_sync_file(int fd) |
277 | { | |
278 | int n = fsync(fd); | |
279 | ||
280 | if (n < 0) | |
281 | return -errno; | |
282 | return n; | |
283 | } | |
284 | ||
c9a3072d | 285 | int os_file_size(const char *file, unsigned long long *size_out) |
1da177e4 LT |
286 | { |
287 | struct uml_stat buf; | |
288 | int err; | |
289 | ||
290 | err = os_stat_file(file, &buf); | |
1adfd609 JD |
291 | if (err < 0) { |
292 | printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file, | |
293 | -err); | |
512b6fb1 | 294 | return err; |
1da177e4 LT |
295 | } |
296 | ||
1adfd609 | 297 | if (S_ISBLK(buf.ust_mode)) { |
2c392a4f NG |
298 | int fd; |
299 | long blocks; | |
1da177e4 | 300 | |
512b6fb1 | 301 | fd = open(file, O_RDONLY, 0); |
1adfd609 | 302 | if (fd < 0) { |
512b6fb1 | 303 | err = -errno; |
1adfd609 JD |
304 | printk(UM_KERN_ERR "Couldn't open \"%s\", " |
305 | "errno = %d\n", file, errno); | |
512b6fb1 | 306 | return err; |
1da177e4 | 307 | } |
1adfd609 | 308 | if (ioctl(fd, BLKGETSIZE, &blocks) < 0) { |
b4fd310e | 309 | err = -errno; |
1adfd609 JD |
310 | printk(UM_KERN_ERR "Couldn't get the block size of " |
311 | "\"%s\", errno = %d\n", file, errno); | |
512b6fb1 JD |
312 | close(fd); |
313 | return err; | |
1da177e4 LT |
314 | } |
315 | *size_out = ((long long) blocks) * 512; | |
512b6fb1 | 316 | close(fd); |
1da177e4 | 317 | } |
512b6fb1 JD |
318 | else *size_out = buf.ust_size; |
319 | ||
320 | return 0; | |
1da177e4 LT |
321 | } |
322 | ||
c9a3072d | 323 | int os_file_modtime(const char *file, unsigned long *modtime) |
1da177e4 LT |
324 | { |
325 | struct uml_stat buf; | |
326 | int err; | |
327 | ||
328 | err = os_stat_file(file, &buf); | |
1adfd609 JD |
329 | if (err < 0) { |
330 | printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file, | |
331 | -err); | |
108ffa8c | 332 | return err; |
1da177e4 LT |
333 | } |
334 | ||
335 | *modtime = buf.ust_mtime; | |
108ffa8c | 336 | return 0; |
1da177e4 LT |
337 | } |
338 | ||
512b6fb1 | 339 | int os_set_exec_close(int fd) |
1da177e4 | 340 | { |
512b6fb1 | 341 | int err; |
1da177e4 | 342 | |
512b6fb1 | 343 | CATCH_EINTR(err = fcntl(fd, F_SETFD, FD_CLOEXEC)); |
1da177e4 | 344 | |
1adfd609 | 345 | if (err < 0) |
512b6fb1 JD |
346 | return -errno; |
347 | return err; | |
1da177e4 LT |
348 | } |
349 | ||
350 | int os_pipe(int *fds, int stream, int close_on_exec) | |
351 | { | |
352 | int err, type = stream ? SOCK_STREAM : SOCK_DGRAM; | |
353 | ||
354 | err = socketpair(AF_UNIX, type, 0, fds); | |
1adfd609 | 355 | if (err < 0) |
512b6fb1 | 356 | return -errno; |
1da177e4 | 357 | |
1adfd609 | 358 | if (!close_on_exec) |
512b6fb1 | 359 | return 0; |
1da177e4 | 360 | |
512b6fb1 | 361 | err = os_set_exec_close(fds[0]); |
1adfd609 | 362 | if (err < 0) |
1da177e4 LT |
363 | goto error; |
364 | ||
512b6fb1 | 365 | err = os_set_exec_close(fds[1]); |
1adfd609 | 366 | if (err < 0) |
1da177e4 LT |
367 | goto error; |
368 | ||
108ffa8c | 369 | return 0; |
1da177e4 LT |
370 | |
371 | error: | |
1adfd609 JD |
372 | printk(UM_KERN_ERR "os_pipe : Setting FD_CLOEXEC failed, err = %d\n", |
373 | -err); | |
512b6fb1 JD |
374 | close(fds[1]); |
375 | close(fds[0]); | |
376 | return err; | |
1da177e4 LT |
377 | } |
378 | ||
bf8fde78 | 379 | int os_set_fd_async(int fd) |
1da177e4 | 380 | { |
bf8fde78 JD |
381 | int err, flags; |
382 | ||
383 | flags = fcntl(fd, F_GETFL); | |
384 | if (flags < 0) | |
385 | return -errno; | |
b4fd310e | 386 | |
bf8fde78 JD |
387 | flags |= O_ASYNC | O_NONBLOCK; |
388 | if (fcntl(fd, F_SETFL, flags) < 0) { | |
b4fd310e | 389 | err = -errno; |
1adfd609 JD |
390 | printk(UM_KERN_ERR "os_set_fd_async : failed to set O_ASYNC " |
391 | "and O_NONBLOCK on fd # %d, errno = %d\n", fd, errno); | |
b4fd310e | 392 | return err; |
1da177e4 | 393 | } |
1da177e4 | 394 | |
bf8fde78 JD |
395 | if ((fcntl(fd, F_SETSIG, SIGIO) < 0) || |
396 | (fcntl(fd, F_SETOWN, os_getpid()) < 0)) { | |
b4fd310e | 397 | err = -errno; |
1adfd609 | 398 | printk(UM_KERN_ERR "os_set_fd_async : Failed to fcntl F_SETOWN " |
bf8fde78 | 399 | "(or F_SETSIG) fd %d, errno = %d\n", fd, errno); |
b4fd310e | 400 | return err; |
1da177e4 LT |
401 | } |
402 | ||
108ffa8c | 403 | return 0; |
1da177e4 LT |
404 | } |
405 | ||
406 | int os_clear_fd_async(int fd) | |
407 | { | |
1adfd609 JD |
408 | int flags; |
409 | ||
410 | flags = fcntl(fd, F_GETFL); | |
411 | if (flags < 0) | |
412 | return -errno; | |
1da177e4 LT |
413 | |
414 | flags &= ~(O_ASYNC | O_NONBLOCK); | |
1adfd609 | 415 | if (fcntl(fd, F_SETFL, flags) < 0) |
108ffa8c JD |
416 | return -errno; |
417 | return 0; | |
1da177e4 LT |
418 | } |
419 | ||
420 | int os_set_fd_block(int fd, int blocking) | |
421 | { | |
422 | int flags; | |
423 | ||
424 | flags = fcntl(fd, F_GETFL); | |
1adfd609 JD |
425 | if (flags < 0) |
426 | return -errno; | |
1da177e4 | 427 | |
1adfd609 JD |
428 | if (blocking) |
429 | flags &= ~O_NONBLOCK; | |
430 | else | |
431 | flags |= O_NONBLOCK; | |
1da177e4 | 432 | |
1adfd609 | 433 | if (fcntl(fd, F_SETFL, flags) < 0) |
b4fd310e JD |
434 | return -errno; |
435 | ||
108ffa8c | 436 | return 0; |
1da177e4 LT |
437 | } |
438 | ||
439 | int os_accept_connection(int fd) | |
440 | { | |
441 | int new; | |
442 | ||
443 | new = accept(fd, NULL, 0); | |
1adfd609 | 444 | if (new < 0) |
108ffa8c JD |
445 | return -errno; |
446 | return new; | |
1da177e4 LT |
447 | } |
448 | ||
449 | #ifndef SHUT_RD | |
450 | #define SHUT_RD 0 | |
451 | #endif | |
452 | ||
453 | #ifndef SHUT_WR | |
454 | #define SHUT_WR 1 | |
455 | #endif | |
456 | ||
457 | #ifndef SHUT_RDWR | |
458 | #define SHUT_RDWR 2 | |
459 | #endif | |
460 | ||
461 | int os_shutdown_socket(int fd, int r, int w) | |
462 | { | |
463 | int what, err; | |
464 | ||
1adfd609 JD |
465 | if (r && w) |
466 | what = SHUT_RDWR; | |
467 | else if (r) | |
468 | what = SHUT_RD; | |
469 | else if (w) | |
470 | what = SHUT_WR; | |
471 | else | |
108ffa8c | 472 | return -EINVAL; |
1adfd609 | 473 | |
1da177e4 | 474 | err = shutdown(fd, what); |
1adfd609 | 475 | if (err < 0) |
108ffa8c JD |
476 | return -errno; |
477 | return 0; | |
1da177e4 LT |
478 | } |
479 | ||
480 | int os_rcv_fd(int fd, int *helper_pid_out) | |
481 | { | |
482 | int new, n; | |
483 | char buf[CMSG_SPACE(sizeof(new))]; | |
484 | struct msghdr msg; | |
485 | struct cmsghdr *cmsg; | |
486 | struct iovec iov; | |
487 | ||
488 | msg.msg_name = NULL; | |
489 | msg.msg_namelen = 0; | |
490 | iov = ((struct iovec) { .iov_base = helper_pid_out, | |
491 | .iov_len = sizeof(*helper_pid_out) }); | |
492 | msg.msg_iov = &iov; | |
493 | msg.msg_iovlen = 1; | |
494 | msg.msg_control = buf; | |
495 | msg.msg_controllen = sizeof(buf); | |
496 | msg.msg_flags = 0; | |
497 | ||
498 | n = recvmsg(fd, &msg, 0); | |
1adfd609 | 499 | if (n < 0) |
108ffa8c | 500 | return -errno; |
1adfd609 | 501 | else if (n != iov.iov_len) |
1da177e4 LT |
502 | *helper_pid_out = -1; |
503 | ||
504 | cmsg = CMSG_FIRSTHDR(&msg); | |
1adfd609 JD |
505 | if (cmsg == NULL) { |
506 | printk(UM_KERN_ERR "rcv_fd didn't receive anything, " | |
507 | "error = %d\n", errno); | |
108ffa8c | 508 | return -1; |
1da177e4 | 509 | } |
1adfd609 JD |
510 | if ((cmsg->cmsg_level != SOL_SOCKET) || |
511 | (cmsg->cmsg_type != SCM_RIGHTS)) { | |
512 | printk(UM_KERN_ERR "rcv_fd didn't receive a descriptor\n"); | |
108ffa8c | 513 | return -1; |
1da177e4 LT |
514 | } |
515 | ||
516 | new = ((int *) CMSG_DATA(cmsg))[0]; | |
108ffa8c | 517 | return new; |
1da177e4 LT |
518 | } |
519 | ||
c9a3072d | 520 | int os_create_unix_socket(const char *file, int len, int close_on_exec) |
1da177e4 LT |
521 | { |
522 | struct sockaddr_un addr; | |
523 | int sock, err; | |
524 | ||
525 | sock = socket(PF_UNIX, SOCK_DGRAM, 0); | |
1adfd609 | 526 | if (sock < 0) |
b4fd310e | 527 | return -errno; |
1da177e4 | 528 | |
1adfd609 | 529 | if (close_on_exec) { |
512b6fb1 | 530 | err = os_set_exec_close(sock); |
1adfd609 JD |
531 | if (err < 0) |
532 | printk(UM_KERN_ERR "create_unix_socket : " | |
533 | "close_on_exec failed, err = %d", -err); | |
1da177e4 LT |
534 | } |
535 | ||
536 | addr.sun_family = AF_UNIX; | |
537 | ||
1da177e4 LT |
538 | snprintf(addr.sun_path, len, "%s", file); |
539 | ||
540 | err = bind(sock, (struct sockaddr *) &addr, sizeof(addr)); | |
1adfd609 | 541 | if (err < 0) |
b4fd310e | 542 | return -errno; |
1da177e4 | 543 | |
108ffa8c | 544 | return sock; |
1da177e4 LT |
545 | } |
546 | ||
547 | void os_flush_stdout(void) | |
548 | { | |
549 | fflush(stdout); | |
550 | } | |
551 | ||
552 | int os_lock_file(int fd, int excl) | |
553 | { | |
554 | int type = excl ? F_WRLCK : F_RDLCK; | |
555 | struct flock lock = ((struct flock) { .l_type = type, | |
556 | .l_whence = SEEK_SET, | |
557 | .l_start = 0, | |
558 | .l_len = 0 } ); | |
559 | int err, save; | |
560 | ||
561 | err = fcntl(fd, F_SETLK, &lock); | |
1adfd609 | 562 | if (!err) |
1da177e4 LT |
563 | goto out; |
564 | ||
565 | save = -errno; | |
566 | err = fcntl(fd, F_GETLK, &lock); | |
1adfd609 | 567 | if (err) { |
1da177e4 LT |
568 | err = -errno; |
569 | goto out; | |
570 | } | |
571 | ||
1adfd609 JD |
572 | printk(UM_KERN_ERR "F_SETLK failed, file already locked by pid %d\n", |
573 | lock.l_pid); | |
1da177e4 LT |
574 | err = save; |
575 | out: | |
108ffa8c | 576 | return err; |
1da177e4 | 577 | } |
005a59ec AV |
578 | |
579 | unsigned os_major(unsigned long long dev) | |
580 | { | |
581 | return major(dev); | |
582 | } | |
583 | ||
584 | unsigned os_minor(unsigned long long dev) | |
585 | { | |
586 | return minor(dev); | |
587 | } | |
588 | ||
589 | unsigned long long os_makedev(unsigned major, unsigned minor) | |
590 | { | |
591 | return makedev(major, minor); | |
592 | } |