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