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