Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
0004  */
0005 
0006 #include <stdio.h>
0007 #include <unistd.h>
0008 #include <stdlib.h>
0009 #include <string.h>
0010 #include <errno.h>
0011 #include <fcntl.h>
0012 #include <signal.h>
0013 #include <linux/falloc.h>
0014 #include <sys/ioctl.h>
0015 #include <sys/mount.h>
0016 #include <sys/socket.h>
0017 #include <sys/stat.h>
0018 #include <sys/sysmacros.h>
0019 #include <sys/un.h>
0020 #include <sys/types.h>
0021 #include <sys/eventfd.h>
0022 #include <poll.h>
0023 #include <os.h>
0024 
0025 static void copy_stat(struct uml_stat *dst, const struct stat64 *src)
0026 {
0027     *dst = ((struct uml_stat) {
0028         .ust_dev     = src->st_dev,     /* device */
0029         .ust_ino     = src->st_ino,     /* inode */
0030         .ust_mode    = src->st_mode,    /* protection */
0031         .ust_nlink   = src->st_nlink,   /* number of hard links */
0032         .ust_uid     = src->st_uid,     /* user ID of owner */
0033         .ust_gid     = src->st_gid,     /* group ID of owner */
0034         .ust_size    = src->st_size,    /* total size, in bytes */
0035         .ust_blksize = src->st_blksize, /* blocksize for filesys I/O */
0036         .ust_blocks  = src->st_blocks,  /* number of blocks allocated */
0037         .ust_atime   = src->st_atime,   /* time of last access */
0038         .ust_mtime   = src->st_mtime,   /* time of last modification */
0039         .ust_ctime   = src->st_ctime,   /* time of last change */
0040     });
0041 }
0042 
0043 int os_stat_fd(const int fd, struct uml_stat *ubuf)
0044 {
0045     struct stat64 sbuf;
0046     int err;
0047 
0048     CATCH_EINTR(err = fstat64(fd, &sbuf));
0049     if (err < 0)
0050         return -errno;
0051 
0052     if (ubuf != NULL)
0053         copy_stat(ubuf, &sbuf);
0054     return err;
0055 }
0056 
0057 int os_stat_file(const char *file_name, struct uml_stat *ubuf)
0058 {
0059     struct stat64 sbuf;
0060     int err;
0061 
0062     CATCH_EINTR(err = stat64(file_name, &sbuf));
0063     if (err < 0)
0064         return -errno;
0065 
0066     if (ubuf != NULL)
0067         copy_stat(ubuf, &sbuf);
0068     return err;
0069 }
0070 
0071 int os_access(const char *file, int mode)
0072 {
0073     int amode, err;
0074 
0075     amode = (mode & OS_ACC_R_OK ? R_OK : 0) |
0076         (mode & OS_ACC_W_OK ? W_OK : 0) |
0077         (mode & OS_ACC_X_OK ? X_OK : 0) |
0078         (mode & OS_ACC_F_OK ? F_OK : 0);
0079 
0080     err = access(file, amode);
0081     if (err < 0)
0082         return -errno;
0083 
0084     return 0;
0085 }
0086 
0087 /* FIXME? required only by hostaudio (because it passes ioctls verbatim) */
0088 int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg)
0089 {
0090     int err;
0091 
0092     err = ioctl(fd, cmd, arg);
0093     if (err < 0)
0094         return -errno;
0095 
0096     return err;
0097 }
0098 
0099 /* FIXME: ensure namebuf in os_get_if_name is big enough */
0100 int os_get_ifname(int fd, char* namebuf)
0101 {
0102     if (ioctl(fd, SIOCGIFNAME, namebuf) < 0)
0103         return -errno;
0104 
0105     return 0;
0106 }
0107 
0108 int os_set_slip(int fd)
0109 {
0110     int disc, sencap;
0111 
0112     disc = N_SLIP;
0113     if (ioctl(fd, TIOCSETD, &disc) < 0)
0114         return -errno;
0115 
0116     sencap = 0;
0117     if (ioctl(fd, SIOCSIFENCAP, &sencap) < 0)
0118         return -errno;
0119 
0120     return 0;
0121 }
0122 
0123 int os_mode_fd(int fd, int mode)
0124 {
0125     int err;
0126 
0127     CATCH_EINTR(err = fchmod(fd, mode));
0128     if (err < 0)
0129         return -errno;
0130 
0131     return 0;
0132 }
0133 
0134 int os_file_type(char *file)
0135 {
0136     struct uml_stat buf;
0137     int err;
0138 
0139     err = os_stat_file(file, &buf);
0140     if (err < 0)
0141         return err;
0142 
0143     if (S_ISDIR(buf.ust_mode))
0144         return OS_TYPE_DIR;
0145     else if (S_ISLNK(buf.ust_mode))
0146         return OS_TYPE_SYMLINK;
0147     else if (S_ISCHR(buf.ust_mode))
0148         return OS_TYPE_CHARDEV;
0149     else if (S_ISBLK(buf.ust_mode))
0150         return OS_TYPE_BLOCKDEV;
0151     else if (S_ISFIFO(buf.ust_mode))
0152         return OS_TYPE_FIFO;
0153     else if (S_ISSOCK(buf.ust_mode))
0154         return OS_TYPE_SOCK;
0155     else return OS_TYPE_FILE;
0156 }
0157 
0158 int os_file_mode(const char *file, struct openflags *mode_out)
0159 {
0160     int err;
0161 
0162     *mode_out = OPENFLAGS();
0163 
0164     err = access(file, W_OK);
0165     if (err && (errno != EACCES))
0166         return -errno;
0167     else if (!err)
0168         *mode_out = of_write(*mode_out);
0169 
0170     err = access(file, R_OK);
0171     if (err && (errno != EACCES))
0172         return -errno;
0173     else if (!err)
0174         *mode_out = of_read(*mode_out);
0175 
0176     return err;
0177 }
0178 
0179 int os_open_file(const char *file, struct openflags flags, int mode)
0180 {
0181     int fd, err, f = 0;
0182 
0183     if (flags.r && flags.w)
0184         f = O_RDWR;
0185     else if (flags.r)
0186         f = O_RDONLY;
0187     else if (flags.w)
0188         f = O_WRONLY;
0189     else f = 0;
0190 
0191     if (flags.s)
0192         f |= O_SYNC;
0193     if (flags.c)
0194         f |= O_CREAT;
0195     if (flags.t)
0196         f |= O_TRUNC;
0197     if (flags.e)
0198         f |= O_EXCL;
0199     if (flags.a)
0200         f |= O_APPEND;
0201 
0202     fd = open64(file, f, mode);
0203     if (fd < 0)
0204         return -errno;
0205 
0206     if (flags.cl && fcntl(fd, F_SETFD, 1)) {
0207         err = -errno;
0208         close(fd);
0209         return err;
0210     }
0211 
0212     return fd;
0213 }
0214 
0215 int os_connect_socket(const char *name)
0216 {
0217     struct sockaddr_un sock;
0218     int fd, err;
0219 
0220     sock.sun_family = AF_UNIX;
0221     snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name);
0222 
0223     fd = socket(AF_UNIX, SOCK_STREAM, 0);
0224     if (fd < 0) {
0225         err = -errno;
0226         goto out;
0227     }
0228 
0229     err = connect(fd, (struct sockaddr *) &sock, sizeof(sock));
0230     if (err) {
0231         err = -errno;
0232         goto out_close;
0233     }
0234 
0235     return fd;
0236 
0237 out_close:
0238     close(fd);
0239 out:
0240     return err;
0241 }
0242 
0243 void os_close_file(int fd)
0244 {
0245     close(fd);
0246 }
0247 int os_fsync_file(int fd)
0248 {
0249     if (fsync(fd) < 0)
0250         return -errno;
0251     return 0;
0252 }
0253 
0254 int os_seek_file(int fd, unsigned long long offset)
0255 {
0256     unsigned long long actual;
0257 
0258     actual = lseek64(fd, offset, SEEK_SET);
0259     if (actual != offset)
0260         return -errno;
0261     return 0;
0262 }
0263 
0264 int os_read_file(int fd, void *buf, int len)
0265 {
0266     int n = read(fd, buf, len);
0267 
0268     if (n < 0)
0269         return -errno;
0270     return n;
0271 }
0272 
0273 int os_pread_file(int fd, void *buf, int len, unsigned long long offset)
0274 {
0275     int n = pread(fd, buf, len, offset);
0276 
0277     if (n < 0)
0278         return -errno;
0279     return n;
0280 }
0281 
0282 int os_write_file(int fd, const void *buf, int len)
0283 {
0284     int n = write(fd, (void *) buf, len);
0285 
0286     if (n < 0)
0287         return -errno;
0288     return n;
0289 }
0290 
0291 int os_sync_file(int fd)
0292 {
0293     int n = fdatasync(fd);
0294 
0295     if (n < 0)
0296         return -errno;
0297     return n;
0298 }
0299 
0300 int os_pwrite_file(int fd, const void *buf, int len, unsigned long long offset)
0301 {
0302     int n = pwrite(fd, (void *) buf, len, offset);
0303 
0304     if (n < 0)
0305         return -errno;
0306     return n;
0307 }
0308 
0309 
0310 int os_file_size(const char *file, unsigned long long *size_out)
0311 {
0312     struct uml_stat buf;
0313     int err;
0314 
0315     err = os_stat_file(file, &buf);
0316     if (err < 0) {
0317         printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
0318                -err);
0319         return err;
0320     }
0321 
0322     if (S_ISBLK(buf.ust_mode)) {
0323         int fd;
0324         long blocks;
0325 
0326         fd = open(file, O_RDONLY, 0);
0327         if (fd < 0) {
0328             err = -errno;
0329             printk(UM_KERN_ERR "Couldn't open \"%s\", "
0330                    "errno = %d\n", file, errno);
0331             return err;
0332         }
0333         if (ioctl(fd, BLKGETSIZE, &blocks) < 0) {
0334             err = -errno;
0335             printk(UM_KERN_ERR "Couldn't get the block size of "
0336                    "\"%s\", errno = %d\n", file, errno);
0337             close(fd);
0338             return err;
0339         }
0340         *size_out = ((long long) blocks) * 512;
0341         close(fd);
0342     }
0343     else *size_out = buf.ust_size;
0344 
0345     return 0;
0346 }
0347 
0348 int os_file_modtime(const char *file, long long *modtime)
0349 {
0350     struct uml_stat buf;
0351     int err;
0352 
0353     err = os_stat_file(file, &buf);
0354     if (err < 0) {
0355         printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
0356                -err);
0357         return err;
0358     }
0359 
0360     *modtime = buf.ust_mtime;
0361     return 0;
0362 }
0363 
0364 int os_set_exec_close(int fd)
0365 {
0366     int err;
0367 
0368     CATCH_EINTR(err = fcntl(fd, F_SETFD, FD_CLOEXEC));
0369 
0370     if (err < 0)
0371         return -errno;
0372     return err;
0373 }
0374 
0375 int os_pipe(int *fds, int stream, int close_on_exec)
0376 {
0377     int err, type = stream ? SOCK_STREAM : SOCK_DGRAM;
0378 
0379     err = socketpair(AF_UNIX, type, 0, fds);
0380     if (err < 0)
0381         return -errno;
0382 
0383     if (!close_on_exec)
0384         return 0;
0385 
0386     err = os_set_exec_close(fds[0]);
0387     if (err < 0)
0388         goto error;
0389 
0390     err = os_set_exec_close(fds[1]);
0391     if (err < 0)
0392         goto error;
0393 
0394     return 0;
0395 
0396  error:
0397     printk(UM_KERN_ERR "os_pipe : Setting FD_CLOEXEC failed, err = %d\n",
0398            -err);
0399     close(fds[1]);
0400     close(fds[0]);
0401     return err;
0402 }
0403 
0404 int os_set_fd_async(int fd)
0405 {
0406     int err, flags;
0407 
0408     flags = fcntl(fd, F_GETFL);
0409     if (flags < 0)
0410         return -errno;
0411 
0412     flags |= O_ASYNC | O_NONBLOCK;
0413     if (fcntl(fd, F_SETFL, flags) < 0) {
0414         err = -errno;
0415         printk(UM_KERN_ERR "os_set_fd_async : failed to set O_ASYNC "
0416                "and O_NONBLOCK on fd # %d, errno = %d\n", fd, errno);
0417         return err;
0418     }
0419 
0420     if ((fcntl(fd, F_SETSIG, SIGIO) < 0) ||
0421         (fcntl(fd, F_SETOWN, os_getpid()) < 0)) {
0422         err = -errno;
0423         printk(UM_KERN_ERR "os_set_fd_async : Failed to fcntl F_SETOWN "
0424                "(or F_SETSIG) fd %d, errno = %d\n", fd, errno);
0425         return err;
0426     }
0427 
0428     return 0;
0429 }
0430 
0431 int os_clear_fd_async(int fd)
0432 {
0433     int flags;
0434 
0435     flags = fcntl(fd, F_GETFL);
0436     if (flags < 0)
0437         return -errno;
0438 
0439     flags &= ~(O_ASYNC | O_NONBLOCK);
0440     if (fcntl(fd, F_SETFL, flags) < 0)
0441         return -errno;
0442     return 0;
0443 }
0444 
0445 int os_set_fd_block(int fd, int blocking)
0446 {
0447     int flags;
0448 
0449     flags = fcntl(fd, F_GETFL);
0450     if (flags < 0)
0451         return -errno;
0452 
0453     if (blocking)
0454         flags &= ~O_NONBLOCK;
0455     else
0456         flags |= O_NONBLOCK;
0457 
0458     if (fcntl(fd, F_SETFL, flags) < 0)
0459         return -errno;
0460 
0461     return 0;
0462 }
0463 
0464 int os_accept_connection(int fd)
0465 {
0466     int new;
0467 
0468     new = accept(fd, NULL, 0);
0469     if (new < 0)
0470         return -errno;
0471     return new;
0472 }
0473 
0474 #ifndef SHUT_RD
0475 #define SHUT_RD 0
0476 #endif
0477 
0478 #ifndef SHUT_WR
0479 #define SHUT_WR 1
0480 #endif
0481 
0482 #ifndef SHUT_RDWR
0483 #define SHUT_RDWR 2
0484 #endif
0485 
0486 int os_shutdown_socket(int fd, int r, int w)
0487 {
0488     int what, err;
0489 
0490     if (r && w)
0491         what = SHUT_RDWR;
0492     else if (r)
0493         what = SHUT_RD;
0494     else if (w)
0495         what = SHUT_WR;
0496     else
0497         return -EINVAL;
0498 
0499     err = shutdown(fd, what);
0500     if (err < 0)
0501         return -errno;
0502     return 0;
0503 }
0504 
0505 int os_rcv_fd(int fd, int *helper_pid_out)
0506 {
0507     int new, n;
0508     char buf[CMSG_SPACE(sizeof(new))];
0509     struct msghdr msg;
0510     struct cmsghdr *cmsg;
0511     struct iovec iov;
0512 
0513     msg.msg_name = NULL;
0514     msg.msg_namelen = 0;
0515     iov = ((struct iovec) { .iov_base  = helper_pid_out,
0516                 .iov_len   = sizeof(*helper_pid_out) });
0517     msg.msg_iov = &iov;
0518     msg.msg_iovlen = 1;
0519     msg.msg_control = buf;
0520     msg.msg_controllen = sizeof(buf);
0521     msg.msg_flags = 0;
0522 
0523     n = recvmsg(fd, &msg, 0);
0524     if (n < 0)
0525         return -errno;
0526     else if (n != iov.iov_len)
0527         *helper_pid_out = -1;
0528 
0529     cmsg = CMSG_FIRSTHDR(&msg);
0530     if (cmsg == NULL) {
0531         printk(UM_KERN_ERR "rcv_fd didn't receive anything, "
0532                "error = %d\n", errno);
0533         return -1;
0534     }
0535     if ((cmsg->cmsg_level != SOL_SOCKET) ||
0536         (cmsg->cmsg_type != SCM_RIGHTS)) {
0537         printk(UM_KERN_ERR "rcv_fd didn't receive a descriptor\n");
0538         return -1;
0539     }
0540 
0541     new = ((int *) CMSG_DATA(cmsg))[0];
0542     return new;
0543 }
0544 
0545 int os_create_unix_socket(const char *file, int len, int close_on_exec)
0546 {
0547     struct sockaddr_un addr;
0548     int sock, err;
0549 
0550     sock = socket(PF_UNIX, SOCK_DGRAM, 0);
0551     if (sock < 0)
0552         return -errno;
0553 
0554     if (close_on_exec) {
0555         err = os_set_exec_close(sock);
0556         if (err < 0)
0557             printk(UM_KERN_ERR "create_unix_socket : "
0558                    "close_on_exec failed, err = %d", -err);
0559     }
0560 
0561     addr.sun_family = AF_UNIX;
0562 
0563     snprintf(addr.sun_path, len, "%s", file);
0564 
0565     err = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
0566     if (err < 0)
0567         return -errno;
0568 
0569     return sock;
0570 }
0571 
0572 void os_flush_stdout(void)
0573 {
0574     fflush(stdout);
0575 }
0576 
0577 int os_lock_file(int fd, int excl)
0578 {
0579     int type = excl ? F_WRLCK : F_RDLCK;
0580     struct flock lock = ((struct flock) { .l_type   = type,
0581                           .l_whence = SEEK_SET,
0582                           .l_start  = 0,
0583                           .l_len    = 0 } );
0584     int err, save;
0585 
0586     err = fcntl(fd, F_SETLK, &lock);
0587     if (!err)
0588         goto out;
0589 
0590     save = -errno;
0591     err = fcntl(fd, F_GETLK, &lock);
0592     if (err) {
0593         err = -errno;
0594         goto out;
0595     }
0596 
0597     printk(UM_KERN_ERR "F_SETLK failed, file already locked by pid %d\n",
0598            lock.l_pid);
0599     err = save;
0600  out:
0601     return err;
0602 }
0603 
0604 unsigned os_major(unsigned long long dev)
0605 {
0606     return major(dev);
0607 }
0608 
0609 unsigned os_minor(unsigned long long dev)
0610 {
0611     return minor(dev);
0612 }
0613 
0614 unsigned long long os_makedev(unsigned major, unsigned minor)
0615 {
0616     return makedev(major, minor);
0617 }
0618 
0619 int os_falloc_punch(int fd, unsigned long long offset, int len)
0620 {
0621     int n = fallocate(fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE, offset, len);
0622 
0623     if (n < 0)
0624         return -errno;
0625     return n;
0626 }
0627 
0628 int os_falloc_zeroes(int fd, unsigned long long offset, int len)
0629 {
0630     int n = fallocate(fd, FALLOC_FL_ZERO_RANGE|FALLOC_FL_KEEP_SIZE, offset, len);
0631 
0632     if (n < 0)
0633         return -errno;
0634     return n;
0635 }
0636 
0637 int os_eventfd(unsigned int initval, int flags)
0638 {
0639     int fd = eventfd(initval, flags);
0640 
0641     if (fd < 0)
0642         return -errno;
0643     return fd;
0644 }
0645 
0646 int os_sendmsg_fds(int fd, const void *buf, unsigned int len, const int *fds,
0647            unsigned int fds_num)
0648 {
0649     struct iovec iov = {
0650         .iov_base = (void *) buf,
0651         .iov_len = len,
0652     };
0653     union {
0654         char control[CMSG_SPACE(sizeof(*fds) * OS_SENDMSG_MAX_FDS)];
0655         struct cmsghdr align;
0656     } u;
0657     unsigned int fds_size = sizeof(*fds) * fds_num;
0658     struct msghdr msg = {
0659         .msg_iov = &iov,
0660         .msg_iovlen = 1,
0661         .msg_control = u.control,
0662         .msg_controllen = CMSG_SPACE(fds_size),
0663     };
0664     struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
0665     int err;
0666 
0667     if (fds_num > OS_SENDMSG_MAX_FDS)
0668         return -EINVAL;
0669     memset(u.control, 0, sizeof(u.control));
0670     cmsg->cmsg_level = SOL_SOCKET;
0671     cmsg->cmsg_type = SCM_RIGHTS;
0672     cmsg->cmsg_len = CMSG_LEN(fds_size);
0673     memcpy(CMSG_DATA(cmsg), fds, fds_size);
0674     err = sendmsg(fd, &msg, 0);
0675 
0676     if (err < 0)
0677         return -errno;
0678     return err;
0679 }
0680 
0681 int os_poll(unsigned int n, const int *fds)
0682 {
0683     /* currently need 2 FDs at most so avoid dynamic allocation */
0684     struct pollfd pollfds[2] = {};
0685     unsigned int i;
0686     int ret;
0687 
0688     if (n > ARRAY_SIZE(pollfds))
0689         return -EINVAL;
0690 
0691     for (i = 0; i < n; i++) {
0692         pollfds[i].fd = fds[i];
0693         pollfds[i].events = POLLIN;
0694     }
0695 
0696     ret = poll(pollfds, n, -1);
0697     if (ret < 0)
0698         return -errno;
0699 
0700     /* Return the index of the available FD */
0701     for (i = 0; i < n; i++) {
0702         if (pollfds[i].revents)
0703             return i;
0704     }
0705 
0706     return -EIO;
0707 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!