arch/um/os-Linux/file.c

   1 /*
   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 <termios.h>
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14 #include <sys/socket.h>
  15 #include <sys/un.h>
  16 #include <sys/ioctl.h>
  17 #include <sys/mount.h>
  18 #include <sys/uio.h>
  19 #include "os.h"
  20 #include "user.h"
  21 #include "kern_util.h"
  22
  23 static void copy_stat(struct uml_stat *dst, struct stat64 *src)
  24 {
  25         *dst = ((struct uml_stat) {
  26                 .ust_dev     = src->st_dev,     /* device */
  27                 .ust_ino     = src->st_ino,     /* inode */
  28                 .ust_mode    = src->st_mode,    /* protection */
  29                 .ust_nlink   = src->st_nlink,   /* number of hard links */
  30                 .ust_uid     = src->st_uid,     /* user ID of owner */
  31                 .ust_gid     = src->st_gid,     /* group ID of owner */
  32                 .ust_size    = src->st_size,    /* total size, in bytes */
  33                 .ust_blksize = src->st_blksize, /* blocksize for filesys I/O */
  34                 .ust_blocks  = src->st_blocks,  /* number of blocks allocated */
  35                 .ust_atime   = src->st_atime,   /* time of last access */
  36                 .ust_mtime   = src->st_mtime,   /* time of last modification */
  37                 .ust_ctime   = src->st_ctime,   /* time of last change */
  38         });
  39 }
  40
  41 int os_stat_fd(const int fd, struct uml_stat *ubuf)
  42 {
  43         struct stat64 sbuf;
  44         int err;
  45
  46         do {
  47                 err = fstat64(fd, &sbuf);
  48         } while((err < 0) && (errno == EINTR)) ;
  49
  50         if(err < 0)
  51                 return(-errno);
  52
  53         if(ubuf != NULL)
  54                 copy_stat(ubuf, &sbuf);
  55         return(err);
  56 }
  57
  58 int os_stat_file(const char *file_name, struct uml_stat *ubuf)
  59 {
  60         struct stat64 sbuf;
  61         int err;
  62
  63         do {
  64                 err = stat64(file_name, &sbuf);
  65         } while((err < 0) && (errno == EINTR)) ;
  66
  67         if(err < 0)
  68                 return(-errno);
  69
  70         if(ubuf != NULL)
  71                 copy_stat(ubuf, &sbuf);
  72         return(err);
  73 }
  74
  75 int os_access(const char* file, int mode)
  76 {
  77         int amode, err;
  78
  79         amode=(mode&OS_ACC_R_OK ? R_OK : 0) | (mode&OS_ACC_W_OK ? W_OK : 0) |
  80               (mode&OS_ACC_X_OK ? X_OK : 0) | (mode&OS_ACC_F_OK ? F_OK : 0) ;
  81
  82         err = access(file, amode);
  83         if(err < 0)
  84                 return(-errno);
  85
  86         return(0);
  87 }
  88
  89 void os_print_error(int error, const char* str)
  90 {
  91         errno = error < 0 ? -error : error;
  92
  93         perror(str);
  94 }
  95
  96 /* FIXME? required only by hostaudio (because it passes ioctls verbatim) */
  97 int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg)
  98 {
  99         int err;
 100
 101         err = ioctl(fd, cmd, arg);
 102         if(err < 0)
 103                 return(-errno);
 104
 105         return(err);
 106 }
 107
 108 int os_window_size(int fd, int *rows, int *cols)
 109 {
 110         struct winsize size;
 111
 112         if(ioctl(fd, TIOCGWINSZ, &size) < 0)
 113                 return(-errno);
 114
 115         *rows = size.ws_row;
 116         *cols = size.ws_col;
 117
 118         return(0);
 119 }
 120
 121 int os_new_tty_pgrp(int fd, int pid)
 122 {
 123         if(ioctl(fd, TIOCSCTTY, 0) < 0){
 124                 printk("TIOCSCTTY failed, errno = %d\n", errno);
 125                 return(-errno);
 126         }
 127
 128         if(tcsetpgrp(fd, pid) < 0){
 129                 printk("tcsetpgrp failed, errno = %d\n", errno);
 130                 return(-errno);
 131         }
 132
 133         return(0);
 134 }
 135
 136 int os_make_pty_raw(int master)
 137 {
 138         struct termios tt;
 139         int err;
 140
 141         while (((err = tcgetattr(master, &tt)) < 0) && errno == EINTR)
 142                 ;
 143         if(err < 0) {
 144                 printk("os_make_pty_raw : tcgetattr failed, errno = %d\n", errno);
 145                 goto fail;
 146         }
 147
 148         cfmakeraw(&tt);
 149
 150         while (((err = tcsetattr(master, TCSADRAIN, &tt)) < 0) && errno == EINTR)
 151                 ;
 152         if(err < 0) {
 153                 printk("os_make_pty_raw : tcsetattr failed, errno = %d\n", errno);
 154                 goto fail;
 155         }
 156
 157         return 0;
 158 fail:
 159         return -errno;
 160 }
 161
 162 /* FIXME: ensure namebuf in os_get_if_name is big enough */
 163 int os_get_ifname(int fd, char* namebuf)
 164 {
 165         if(ioctl(fd, SIOCGIFNAME, namebuf) < 0)
 166                 return(-errno);
 167
 168         return(0);
 169 }
 170
 171 int os_set_slip(int fd)
 172 {
 173         int disc, sencap;
 174
 175         disc = N_SLIP;
 176         if(ioctl(fd, TIOCSETD, &disc) < 0){
 177                 printk("Failed to set slip line discipline - "
 178                        "errno = %d\n", errno);
 179                 return(-errno);
 180         }
 181
 182         sencap = 0;
 183         if(ioctl(fd, SIOCSIFENCAP, &sencap) < 0){
 184                 printk("Failed to set slip encapsulation - "
 185                        "errno = %d\n", errno);
 186                 return(-errno);
 187         }
 188
 189         return(0);
 190 }
 191
 192 int os_set_owner(int fd, int pid)
 193 {
 194         if(fcntl(fd, F_SETOWN, pid) < 0){
 195                 int save_errno = errno;
 196
 197                 if(fcntl(fd, F_GETOWN, 0) != pid)
 198                         return(-save_errno);
 199         }
 200
 201         return(0);
 202 }
 203
 204 /* FIXME? moved wholesale from sigio_user.c to get fcntls out of that file */
 205 int os_sigio_async(int master, int slave)
 206 {
 207         int flags;
 208
 209         flags = fcntl(master, F_GETFL);
 210         if(flags < 0) {
 211                 printk("fcntl F_GETFL failed, errno = %d\n", errno);
 212                 return(-errno);
 213         }
 214
 215         if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
 216            (fcntl(master, F_SETOWN, os_getpid()) < 0)){
 217                 printk("fcntl F_SETFL or F_SETOWN failed, errno = %d\n", errno);
 218                 return(-errno);
 219         }
 220
 221         if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0)){
 222                 printk("fcntl F_SETFL failed, errno = %d\n", errno);
 223                 return(-errno);
 224         }
 225
 226         return(0);
 227 }
 228
 229 int os_mode_fd(int fd, int mode)
 230 {
 231         int err;
 232
 233         do {
 234                 err = fchmod(fd, mode);
 235         } while((err < 0) && (errno==EINTR)) ;
 236
 237         if(err < 0)
 238                 return(-errno);
 239
 240         return(0);
 241 }
 242
 243 int os_file_type(char *file)
 244 {
 245         struct uml_stat buf;
 246         int err;
 247
 248         err = os_stat_file(file, &buf);
 249         if(err < 0)
 250                 return(err);
 251
 252         if(S_ISDIR(buf.ust_mode)) return(OS_TYPE_DIR);
 253         else if(S_ISLNK(buf.ust_mode)) return(OS_TYPE_SYMLINK);
 254         else if(S_ISCHR(buf.ust_mode)) return(OS_TYPE_CHARDEV);
 255         else if(S_ISBLK(buf.ust_mode)) return(OS_TYPE_BLOCKDEV);
 256         else if(S_ISFIFO(buf.ust_mode)) return(OS_TYPE_FIFO);
 257         else if(S_ISSOCK(buf.ust_mode)) return(OS_TYPE_SOCK);
 258         else return(OS_TYPE_FILE);
 259 }
 260
 261 int os_file_mode(char *file, struct openflags *mode_out)
 262 {
 263         int err;
 264
 265         *mode_out = OPENFLAGS();
 266
 267         err = os_access(file, OS_ACC_W_OK);
 268         if((err < 0) && (err != -EACCES))
 269                 return(err);
 270
 271         *mode_out = of_write(*mode_out);
 272
 273         err = os_access(file, OS_ACC_R_OK);
 274         if((err < 0) && (err != -EACCES))
 275                 return(err);
 276
 277         *mode_out = of_read(*mode_out);
 278
 279         return(0);
 280 }
 281
 282 int os_open_file(char *file, struct openflags flags, int mode)
 283 {
 284         int fd, f = 0;
 285
 286         if(flags.r && flags.w) f = O_RDWR;
 287         else if(flags.r) f = O_RDONLY;
 288         else if(flags.w) f = O_WRONLY;
 289         else f = 0;
 290
 291         if(flags.s) f |= O_SYNC;
 292         if(flags.c) f |= O_CREAT;
 293         if(flags.t) f |= O_TRUNC;
 294         if(flags.e) f |= O_EXCL;
 295
 296         fd = open64(file, f, mode);
 297         if(fd < 0)
 298                 return(-errno);
 299
 300         if(flags.cl && fcntl(fd, F_SETFD, 1)){
 301                 os_close_file(fd);
 302                 return(-errno);
 303         }
 304
 305         return(fd);
 306 }
 307
 308 int os_connect_socket(char *name)
 309 {
 310         struct sockaddr_un sock;
 311         int fd, err;
 312
 313         sock.sun_family = AF_UNIX;
 314         snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name);
 315
 316         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 317         if(fd < 0)
 318                 return(fd);
 319
 320         err = connect(fd, (struct sockaddr *) &sock, sizeof(sock));
 321         if(err)
 322                 return(-errno);
 323
 324         return(fd);
 325 }
 326
 327 void os_close_file(int fd)
 328 {
 329         close(fd);
 330 }
 331
 332 int os_seek_file(int fd, __u64 offset)
 333 {
 334         __u64 actual;
 335
 336         actual = lseek64(fd, offset, SEEK_SET);
 337         if(actual != offset) return(-errno);
 338         return(0);
 339 }
 340
 341 static int fault_buffer(void *start, int len,
 342                         int (*copy_proc)(void *addr, void *buf, int len))
 343 {
 344         int page = getpagesize(), i;
 345         char c;
 346
 347         for(i = 0; i < len; i += page){
 348                 if((*copy_proc)(start + i, &c, sizeof(c)))
 349                         return(-EFAULT);
 350         }
 351         if((len % page) != 0){
 352                 if((*copy_proc)(start + len - 1, &c, sizeof(c)))
 353                         return(-EFAULT);
 354         }
 355         return(0);
 356 }
 357
 358 static int file_io(int fd, void *buf, int len,
 359                    int (*io_proc)(int fd, void *buf, int len),
 360                    int (*copy_user_proc)(void *addr, void *buf, int len))
 361 {
 362         int n, err;
 363
 364         do {
 365                 n = (*io_proc)(fd, buf, len);
 366                 if((n < 0) && (errno == EFAULT)){
 367                         err = fault_buffer(buf, len, copy_user_proc);
 368                         if(err)
 369                                 return(err);
 370                         n = (*io_proc)(fd, buf, len);
 371                 }
 372         } while((n < 0) && (errno == EINTR));
 373
 374         if(n < 0)
 375                 return(-errno);
 376         return(n);
 377 }
 378
 379 int os_read_file(int fd, void *buf, int len)
 380 {
 381         return(file_io(fd, buf, len, (int (*)(int, void *, int)) read,
 382                        copy_from_user_proc));
 383 }
 384
 385 int os_write_file(int fd, const void *buf, int len)
 386 {
 387         return(file_io(fd, (void *) buf, len,
 388                        (int (*)(int, void *, int)) write, copy_to_user_proc));
 389 }
 390
 391 int os_file_size(char *file, long long *size_out)
 392 {
 393         struct uml_stat buf;
 394         int err;
 395
 396         err = os_stat_file(file, &buf);
 397         if(err < 0){
 398                 printk("Couldn't stat \"%s\" : err = %d\n", file, -err);
 399                 return(err);
 400         }
 401
 402         if(S_ISBLK(buf.ust_mode)){
 403                 int fd, blocks;
 404
 405                 fd = os_open_file(file, of_read(OPENFLAGS()), 0);
 406                 if(fd < 0){
 407                         printk("Couldn't open \"%s\", errno = %d\n", file, -fd);
 408                         return(fd);
 409                 }
 410                 if(ioctl(fd, BLKGETSIZE, &blocks) < 0){
 411                         printk("Couldn't get the block size of \"%s\", "
 412                                "errno = %d\n", file, errno);
 413                         err = -errno;
 414                         os_close_file(fd);
 415                         return(err);
 416                 }
 417                 *size_out = ((long long) blocks) * 512;
 418                 os_close_file(fd);
 419                 return(0);
 420         }
 421         *size_out = buf.ust_size;
 422         return(0);
 423 }
 424
 425 int os_file_modtime(char *file, unsigned long *modtime)
 426 {
 427         struct uml_stat buf;
 428         int err;
 429
 430         err = os_stat_file(file, &buf);
 431         if(err < 0){
 432                 printk("Couldn't stat \"%s\" : err = %d\n", file, -err);
 433                 return(err);
 434         }
 435
 436         *modtime = buf.ust_mtime;
 437         return(0);
 438 }
 439
 440 int os_get_exec_close(int fd, int* close_on_exec)
 441 {
 442         int ret;
 443
 444         do {
 445                 ret = fcntl(fd, F_GETFD);
 446         } while((ret < 0) && (errno == EINTR)) ;
 447
 448         if(ret < 0)
 449                 return(-errno);
 450
 451         *close_on_exec = (ret&FD_CLOEXEC) ? 1 : 0;
 452         return(ret);
 453 }
 454
 455 int os_set_exec_close(int fd, int close_on_exec)
 456 {
 457         int flag, err;
 458
 459         if(close_on_exec) flag = FD_CLOEXEC;
 460         else flag = 0;
 461
 462         do {
 463                 err = fcntl(fd, F_SETFD, flag);
 464         } while((err < 0) && (errno == EINTR)) ;
 465
 466         if(err < 0)
 467                 return(-errno);
 468         return(err);
 469 }
 470
 471 int os_pipe(int *fds, int stream, int close_on_exec)
 472 {
 473         int err, type = stream ? SOCK_STREAM : SOCK_DGRAM;
 474
 475         err = socketpair(AF_UNIX, type, 0, fds);
 476         if(err < 0)
 477                 return(-errno);
 478
 479         if(!close_on_exec)
 480                 return(0);
 481
 482         err = os_set_exec_close(fds[0], 1);
 483         if(err < 0)
 484                 goto error;
 485
 486         err = os_set_exec_close(fds[1], 1);
 487         if(err < 0)
 488                 goto error;
 489
 490         return(0);
 491
 492  error:
 493         printk("os_pipe : Setting FD_CLOEXEC failed, err = %d\n", -err);
 494         os_close_file(fds[1]);
 495         os_close_file(fds[0]);
 496         return(err);
 497 }
 498
 499 int os_set_fd_async(int fd, int owner)
 500 {
 501         /* XXX This should do F_GETFL first */
 502         if(fcntl(fd, F_SETFL, O_ASYNC | O_NONBLOCK) < 0){
 503                 printk("os_set_fd_async : failed to set O_ASYNC and "
 504                        "O_NONBLOCK on fd # %d, errno = %d\n", fd, errno);
 505                 return(-errno);
 506         }
 507 #ifdef notdef
 508         if(fcntl(fd, F_SETFD, 1) < 0){
 509                 printk("os_set_fd_async : Setting FD_CLOEXEC failed, "
 510                        "errno = %d\n", errno);
 511         }
 512 #endif
 513
 514         if((fcntl(fd, F_SETSIG, SIGIO) < 0) ||
 515            (fcntl(fd, F_SETOWN, owner) < 0)){
 516                 printk("os_set_fd_async : Failed to fcntl F_SETOWN "
 517                        "(or F_SETSIG) fd %d to pid %d, errno = %d\n", fd,
 518                        owner, errno);
 519                 return(-errno);
 520         }
 521
 522         return(0);
 523 }
 524
 525 int os_set_fd_block(int fd, int blocking)
 526 {
 527         int flags;
 528
 529         flags = fcntl(fd, F_GETFL);
 530
 531         if(blocking) flags &= ~O_NONBLOCK;
 532         else flags |= O_NONBLOCK;
 533
 534         if(fcntl(fd, F_SETFL, flags) < 0){
 535                 printk("Failed to change blocking on fd # %d, errno = %d\n",
 536                        fd, errno);
 537                 return(-errno);
 538         }
 539         return(0);
 540 }
 541
 542 int os_accept_connection(int fd)
 543 {
 544         int new;
 545
 546         new = accept(fd, NULL, 0);
 547         if(new < 0)
 548                 return(-errno);
 549         return(new);
 550 }
 551
 552 #ifndef SHUT_RD
 553 #define SHUT_RD 0
 554 #endif
 555
 556 #ifndef SHUT_WR
 557 #define SHUT_WR 1
 558 #endif
 559
 560 #ifndef SHUT_RDWR
 561 #define SHUT_RDWR 2
 562 #endif
 563
 564 int os_shutdown_socket(int fd, int r, int w)
 565 {
 566         int what, err;
 567
 568         if(r && w) what = SHUT_RDWR;
 569         else if(r) what = SHUT_RD;
 570         else if(w) what = SHUT_WR;
 571         else {
 572                 printk("os_shutdown_socket : neither r or w was set\n");
 573                 return(-EINVAL);
 574         }
 575         err = shutdown(fd, what);
 576         if(err < 0)
 577                 return(-errno);
 578         return(0);
 579 }
 580
 581 int os_rcv_fd(int fd, int *helper_pid_out)
 582 {
 583         int new, n;
 584         char buf[CMSG_SPACE(sizeof(new))];
 585         struct msghdr msg;
 586         struct cmsghdr *cmsg;
 587         struct iovec iov;
 588
 589         msg.msg_name = NULL;
 590         msg.msg_namelen = 0;
 591         iov = ((struct iovec) { .iov_base  = helper_pid_out,
 592                                 .iov_len   = sizeof(*helper_pid_out) });
 593         msg.msg_iov = &iov;
 594         msg.msg_iovlen = 1;
 595         msg.msg_control = buf;
 596         msg.msg_controllen = sizeof(buf);
 597         msg.msg_flags = 0;
 598
 599         n = recvmsg(fd, &msg, 0);
 600         if(n < 0)
 601                 return(-errno);
 602
 603         else if(n != sizeof(iov.iov_len))
 604                 *helper_pid_out = -1;
 605
 606         cmsg = CMSG_FIRSTHDR(&msg);
 607         if(cmsg == NULL){
 608                 printk("rcv_fd didn't receive anything, error = %d\n", errno);
 609                 return(-1);
 610         }
 611         if((cmsg->cmsg_level != SOL_SOCKET) ||
 612            (cmsg->cmsg_type != SCM_RIGHTS)){
 613                 printk("rcv_fd didn't receive a descriptor\n");
 614                 return(-1);
 615         }
 616
 617         new = ((int *) CMSG_DATA(cmsg))[0];
 618         return(new);
 619 }
 620
 621 int os_create_unix_socket(char *file, int len, int close_on_exec)
 622 {
 623         struct sockaddr_un addr;
 624         int sock, err;
 625
 626         sock = socket(PF_UNIX, SOCK_DGRAM, 0);
 627         if (sock < 0){
 628                 printk("create_unix_socket - socket failed, errno = %d\n",
 629                        errno);
 630                 return(-errno);
 631         }
 632
 633         if(close_on_exec) {
 634                 err = os_set_exec_close(sock, 1);
 635                 if(err < 0)
 636                         printk("create_unix_socket : close_on_exec failed, "
 637                        "err = %d", -err);
 638         }
 639
 640         addr.sun_family = AF_UNIX;
 641
 642         /* XXX Be more careful about overflow */
 643         snprintf(addr.sun_path, len, "%s", file);
 644
 645         err = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
 646         if (err < 0){
 647                 printk("create_listening_socket at '%s' - bind failed, "
 648                        "errno = %d\n", file, errno);
 649                 return(-errno);
 650         }
 651
 652         return(sock);
 653 }
 654
 655 void os_flush_stdout(void)
 656 {
 657         fflush(stdout);
 658 }
 659
 660 int os_lock_file(int fd, int excl)
 661 {
 662         int type = excl ? F_WRLCK : F_RDLCK;
 663         struct flock lock = ((struct flock) { .l_type   = type,
 664                                               .l_whence = SEEK_SET,
 665                                               .l_start  = 0,
 666                                               .l_len    = 0 } );
 667         int err, save;
 668
 669         err = fcntl(fd, F_SETLK, &lock);
 670         if(!err)
 671                 goto out;
 672
 673         save = -errno;
 674         err = fcntl(fd, F_GETLK, &lock);
 675         if(err){
 676                 err = -errno;
 677                 goto out;
 678         }
 679
 680         printk("F_SETLK failed, file already locked by pid %d\n", lock.l_pid);
 681         err = save;
 682  out:
 683         return(err);
 684 }
 685
 686 /*
 687  * Overrides for Emacs so that we follow Linus's tabbing style.
 688  * Emacs will notice this stuff at the end of the file and automatically
 689  * adjust the settings for this buffer only.  This must remain at the end
 690  * of the file.
 691  * ---------------------------------------------------------------------------
 692  * Local variables:
 693  * c-file-style: "linux"
 694  * End:
 695  */