Source-Changes-HG archive

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]

[src/trunk]: src/sys/kern Change STD[:random-whitespace:]RUMP to STD\tRUMP



details:   https://anonhg.NetBSD.org/src/rev/9052ddff51fc
branches:  trunk
changeset: 971053:9052ddff51fc
user:      christos <christos%NetBSD.org@localhost>
date:      Sun Apr 12 13:30:16 2020 +0000

description:
Change STD[:random-whitespace:]RUMP to STD\tRUMP

diffstat:

 sys/kern/syscalls.master |  362 +++++++++++++++++++++++-----------------------
 1 files changed, 181 insertions(+), 181 deletions(-)

diffs (truncated from 775 to 300 lines):

diff -r 89a036b69367 -r 9052ddff51fc sys/kern/syscalls.master
--- a/sys/kern/syscalls.master  Sun Apr 12 13:12:42 2020 +0000
+++ b/sys/kern/syscalls.master  Sun Apr 12 13:30:16 2020 +0000
@@ -1,4 +1,4 @@
-       $NetBSD: syscalls.master,v 1.298 2020/04/04 20:20:12 thorpej Exp $
+       $NetBSD: syscalls.master,v 1.299 2020/04/12 13:30:16 christos Exp $
 
 ;      @(#)syscalls.master     8.2 (Berkeley) 1/13/94
 
@@ -72,25 +72,25 @@
                            ... register_t args[SYS_MAXSYSARGS]); }
 1      STD             { void|sys||exit(int rval); }
 2      STD             { int|sys||fork(void); }
-3      STD      RUMP   { ssize_t|sys||read(int fd, void *buf, size_t nbyte); }
-4      STD      RUMP   { ssize_t|sys||write(int fd, const void *buf, \
+3      STD     RUMP    { ssize_t|sys||read(int fd, void *buf, size_t nbyte); }
+4      STD     RUMP    { ssize_t|sys||write(int fd, const void *buf, \
                            size_t nbyte); }
-5      STD      RUMP   { int|sys||open(const char *path, \
+5      STD     RUMP    { int|sys||open(const char *path, \
                            int flags, ... mode_t mode); }
-6      STD      RUMP   { int|sys||close(int fd); }
+6      STD     RUMP    { int|sys||close(int fd); }
 7      COMPAT_50 MODULAR compat_50 { int|sys||wait4(pid_t pid, int *status, \
                            int options, struct rusage50 *rusage); }
 8      COMPAT_43 MODULAR compat_43     \
                { int|sys||creat(const char *path, mode_t mode); } ocreat
-9      STD      RUMP   { int|sys||link(const char *path, const char *link); }
-10     STD      RUMP   { int|sys||unlink(const char *path); }
+9      STD     RUMP    { int|sys||link(const char *path, const char *link); }
+10     STD     RUMP    { int|sys||unlink(const char *path); }
 11     OBSOL           execv
-12     STD      RUMP   { int|sys||chdir(const char *path); }
-13     STD      RUMP   { int|sys||fchdir(int fd); }
+12     STD     RUMP    { int|sys||chdir(const char *path); }
+13     STD     RUMP    { int|sys||fchdir(int fd); }
 14     COMPAT_50 MODULAR compat_50 RUMP        \
                { int|sys||mknod(const char *path, mode_t mode, uint32_t dev); }
-15     STD      RUMP   { int|sys||chmod(const char *path, mode_t mode); }
-16     STD      RUMP   { int|sys||chown(const char *path, uid_t uid, \
+15     STD     RUMP    { int|sys||chmod(const char *path, mode_t mode); }
+16     STD     RUMP    { int|sys||chown(const char *path, uid_t uid, \
                            gid_t gid); }
 17     STD             { int|sys||obreak(char *nsize); } break
 18     COMPAT_20 MODULAR compat_20 { int|sys||getfsstat(struct statfs12 *buf, \
@@ -102,18 +102,18 @@
 21     COMPAT_40 MODULAR compat_40     \
                { int|sys||mount(const char *type, const char *path, \
                            int flags, void *data); }
-22     STD     RUMP    { int|sys||unmount(const char *path, int flags); }
-23     STD     RUMP    { int|sys||setuid(uid_t uid); }
+22     STD     RUMP    { int|sys||unmount(const char *path, int flags); }
+23     STD     RUMP    { int|sys||setuid(uid_t uid); }
 24     NOERR   RUMP    { uid_t|sys||getuid_with_euid(void); } getuid
 25     NOERR   RUMP    { uid_t|sys||geteuid(void); }
 26     STD     MODULAR ptrace  \
                        { int|sys||ptrace(int req, pid_t pid, void *addr, \
                            int data); }
-27     STD     RUMP    { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \
+27     STD     RUMP    { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \
                            int flags); }
-28     STD     RUMP    { ssize_t|sys||sendmsg(int s, \
+28     STD     RUMP    { ssize_t|sys||sendmsg(int s, \
                            const struct msghdr *msg, int flags); }
-29     STD     RUMP    { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \
+29     STD     RUMP    { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \
                            int flags, struct sockaddr *from, \
                            socklen_t *fromlenaddr); }
 30     STD     RUMP    { int|sys||accept(int s, struct sockaddr *name, \
@@ -122,9 +122,9 @@
                            socklen_t *alen); }
 32     STD     RUMP    { int|sys||getsockname(int fdes, struct sockaddr *asa, \
                            socklen_t *alen); }
-33     STD     RUMP    { int|sys||access(const char *path, int flags); }
-34     STD      RUMP   { int|sys||chflags(const char *path, u_long flags); }
-35     STD     RUMP    { int|sys||fchflags(int fd, u_long flags); }
+33     STD     RUMP    { int|sys||access(const char *path, int flags); }
+34     STD     RUMP    { int|sys||chflags(const char *path, u_long flags); }
+35     STD     RUMP    { int|sys||fchflags(int fd, u_long flags); }
 36     NOERR    RUMP   { void|sys||sync(void); }
 37     STD             { int|sys||kill(pid_t pid, int signum); }
 38     COMPAT_43 MODULAR compat_43     \
@@ -133,12 +133,12 @@
 40     COMPAT_43 MODULAR compat_43     \
                { int|sys||lstat(const char *path, \
                            struct stat43 *ub); } lstat43
-41     STD     RUMP    { int|sys||dup(int fd); }
-42     STD     RUMP    { int|sys||pipe(void); }
+41     STD     RUMP    { int|sys||dup(int fd); }
+42     STD     RUMP    { int|sys||pipe(void); }
 43     NOERR   RUMP    { gid_t|sys||getegid(void); }
 44     STD             { int|sys||profil(char *samples, size_t size, \
                            u_long offset, u_int scale); }
-45     STD     RUMP    { int|sys||ktrace(const char *fname, int ops, \
+45     STD     RUMP    { int|sys||ktrace(const char *fname, int ops, \
                            int facs, pid_t pid); }
 46     COMPAT_13 MODULAR compat_13 { int|sys||sigaction(int signum, \
                            const struct sigaction13 *nsa, \
@@ -146,8 +146,8 @@
 47     NOERR   RUMP    { gid_t|sys||getgid_with_egid(void); } getgid
 48     COMPAT_13 MODULAR compat_13 { int|sys||sigprocmask(int how, \
                            int mask); } sigprocmask13
-49     STD     RUMP    { int|sys||__getlogin(char *namebuf, size_t namelen); }
-50     STD     RUMP    { int|sys||__setlogin(const char *namebuf); }
+49     STD     RUMP    { int|sys||__getlogin(char *namebuf, size_t namelen); }
+50     STD     RUMP    { int|sys||__setlogin(const char *namebuf); }
 51     STD             { int|sys||acct(const char *path); }
 52     COMPAT_13 MODULAR compat_13 { int|sys||sigpending(void); } sigpending13
 53     COMPAT_13 MODULAR compat_13 { int|sys||sigaltstack( \
@@ -156,15 +156,15 @@
 54     STD     RUMP    { int|sys||ioctl(int fd, \
                            u_long com, ... void *data); }
 55     COMPAT_12 MODULAR compat_12 { int|sys||reboot(int opt); } oreboot
-56     STD      RUMP   { int|sys||revoke(const char *path); }
-57     STD      RUMP   { int|sys||symlink(const char *path, \
+56     STD     RUMP    { int|sys||revoke(const char *path); }
+57     STD     RUMP    { int|sys||symlink(const char *path, \
                            const char *link); }
-58     STD      RUMP   { ssize_t|sys||readlink(const char *path, char *buf, \
+58     STD     RUMP    { ssize_t|sys||readlink(const char *path, char *buf, \
                            size_t count); }
 59     STD             { int|sys||execve(const char *path, \
                            char * const *argp, char * const *envp); }
-60     STD      RUMP   { mode_t|sys||umask(mode_t newmask); }
-61     STD      RUMP   { int|sys||chroot(const char *path); }
+60     STD     RUMP    { mode_t|sys||umask(mode_t newmask); }
+61     STD     RUMP    { int|sys||chroot(const char *path); }
 62     COMPAT_43 MODULAR compat_43     \
                { int|sys||fstat(int fd, struct stat43 *sb); } fstat43
 63     COMPAT_43 MODULAR compat_43     \
@@ -192,12 +192,12 @@
 77     OBSOL           vlimit
 78     STD             { int|sys||mincore(void *addr, size_t len, \
                            char *vec); }
-79     STD     RUMP    { int|sys||getgroups(int gidsetsize, \
+79     STD     RUMP    { int|sys||getgroups(int gidsetsize, \
                            gid_t *gidset); }
-80     STD     RUMP    { int|sys||setgroups(int gidsetsize, \
+80     STD     RUMP    { int|sys||setgroups(int gidsetsize, \
                            const gid_t *gidset); }
-81     STD     RUMP    { int|sys||getpgrp(void); }
-82     STD     RUMP    { int|sys||setpgid(pid_t pid, pid_t pgid); }
+81     STD     RUMP    { int|sys||getpgrp(void); }
+82     STD     RUMP    { int|sys||setpgid(pid_t pid, pid_t pgid); }
 83     COMPAT_50 MODULAR compat_50 { int|sys||setitimer(int which, \
                            const struct itimerval50 *itv, \
                            struct itimerval50 *oitv); }
@@ -214,7 +214,7 @@
                            osethostname
 89     COMPAT_43 MODULAR compat_43     \
                { int|sys||getdtablesize(void); } ogetdtablesize
-90     STD      RUMP   { int|sys||dup2(int from, int to); }
+90     STD     RUMP    { int|sys||dup2(int from, int to); }
 91     UNIMPL          getdopt
 92     STD     RUMP    { int|sys||fcntl(int fd, int cmd, ... void *arg); }
 93     COMPAT_50 MODULAR compat_50 RUMP        \
@@ -265,36 +265,36 @@
 118    STD     RUMP    { int|sys||getsockopt(int s, int level, int name, \
                            void *val, socklen_t *avalsize); }
 119    OBSOL           resuba
-120    STD     RUMP    { ssize_t|sys||readv(int fd, \
+120    STD     RUMP    { ssize_t|sys||readv(int fd, \
                            const struct iovec *iovp, int iovcnt); }
-121    STD     RUMP    { ssize_t|sys||writev(int fd, \
+121    STD     RUMP    { ssize_t|sys||writev(int fd, \
                            const struct iovec *iovp, int iovcnt); }
 122    COMPAT_50 MODULAR compat_50     \
                { int|sys||settimeofday(const struct timeval50 *tv, \
                            const void *tzp); }
-123    STD      RUMP   { int|sys||fchown(int fd, uid_t uid, gid_t gid); }
-124    STD      RUMP   { int|sys||fchmod(int fd, mode_t mode); }
+123    STD     RUMP    { int|sys||fchown(int fd, uid_t uid, gid_t gid); }
+124    STD     RUMP    { int|sys||fchmod(int fd, mode_t mode); }
 125    COMPAT_43 MODULAR compat_43     \
                { int|sys||recvfrom(int s, void *buf, size_t len, \
                            int flags, void *from, socklen_t *fromlenaddr); } \
                            orecvfrom
-126    STD     RUMP    { int|sys||setreuid(uid_t ruid, uid_t euid); }
-127    STD     RUMP    { int|sys||setregid(gid_t rgid, gid_t egid); }
-128    STD      RUMP   { int|sys||rename(const char *from, const char *to); }
+126    STD     RUMP    { int|sys||setreuid(uid_t ruid, uid_t euid); }
+127    STD     RUMP    { int|sys||setregid(gid_t rgid, gid_t egid); }
+128    STD     RUMP    { int|sys||rename(const char *from, const char *to); }
 129    COMPAT_43 MODULAR compat_43     \
                { int|sys||truncate(const char *path, long length); } otruncate
 130    COMPAT_43 MODULAR compat_43     \
                { int|sys||ftruncate(int fd, long length); } oftruncate
-131    STD      RUMP   { int|sys||flock(int fd, int how); }
-132    STD      RUMP   { int|sys||mkfifo(const char *path, mode_t mode); }
-133    STD      RUMP   { ssize_t|sys||sendto(int s, const void *buf, \
+131    STD     RUMP    { int|sys||flock(int fd, int how); }
+132    STD     RUMP    { int|sys||mkfifo(const char *path, mode_t mode); }
+133    STD     RUMP    { ssize_t|sys||sendto(int s, const void *buf, \
                            size_t len, int flags, const struct sockaddr *to, \
                            socklen_t tolen); }
-134    STD      RUMP   { int|sys||shutdown(int s, int how); }
-135    STD      RUMP   { int|sys||socketpair(int domain, int type, \
+134    STD     RUMP    { int|sys||shutdown(int s, int how); }
+135    STD     RUMP    { int|sys||socketpair(int domain, int type, \
                            int protocol, int *rsv); }
-136    STD      RUMP   { int|sys||mkdir(const char *path, mode_t mode); }
-137    STD      RUMP   { int|sys||rmdir(const char *path); }
+136    STD     RUMP    { int|sys||mkdir(const char *path, mode_t mode); }
+137    STD     RUMP    { int|sys||rmdir(const char *path); }
 138    COMPAT_50 MODULAR compat_50 RUMP { int|sys||utimes(const char *path, \
                            const struct timeval50 *tptr); }
 139    OBSOL           4.2 sigreturn
@@ -315,7 +315,7 @@
                            const struct orlimit *rlp); } osetrlimit
 146    COMPAT_43 MODULAR compat_43     \
                { int|sys||killpg(int pgid, int signum); } okillpg
-147    STD     RUMP    { int|sys||setsid(void); }
+147    STD     RUMP    { int|sys||setsid(void); }
 148    COMPAT_50 MODULAR compat_50_quota       \
                { int|sys||quotactl(const char *path, \
                          int cmd, int uid, void *arg); }
@@ -331,7 +331,7 @@
 152    UNIMPL
 153    UNIMPL
 154    UNIMPL
-155    STD MODULAR nfsserver RUMP  { int|sys||nfssvc(int flag, void *argp); }
+155    STD     RUMP  { int|sys||nfssvc(int flag, void *argp); }
 156    COMPAT_43 MODULAR compat_43     \
                { int|sys||getdirentries(int fd, char *buf, \
                            u_int count, long *basep); } ogetdirentries
@@ -380,9 +380,9 @@
 171    EXCL            1.0 shmsys
 #endif
 172    UNIMPL
-173    STD      RUMP   { ssize_t|sys||pread(int fd, void *buf, \
+173    STD     RUMP    { ssize_t|sys||pread(int fd, void *buf, \
                            size_t nbyte, int PAD, off_t offset); }
-174    STD      RUMP   { ssize_t|sys||pwrite(int fd, const void *buf, \
+174    STD     RUMP    { ssize_t|sys||pwrite(int fd, const void *buf, \
                            size_t nbyte, int PAD, off_t offset); }
 ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded.
 175    COMPAT_30 MODULAR compat_30     \
@@ -398,9 +398,9 @@
 180    UNIMPL
 
 ; Syscalls 180-199 are used by/reserved for BSD
-181    STD     RUMP    { int|sys||setgid(gid_t gid); }
-182    STD     RUMP    { int|sys||setegid(gid_t egid); }
-183    STD     RUMP    { int|sys||seteuid(uid_t euid); }
+181    STD     RUMP    { int|sys||setgid(gid_t gid); }
+182    STD     RUMP    { int|sys||setegid(gid_t egid); }
+183    STD     RUMP    { int|sys||seteuid(uid_t euid); }
 184    STD MODULAR lfs { int|sys||lfs_bmapv(fsid_t *fsidp, \
                            struct block_info *blkiov, int blkcnt); }
 185    STD MODULAR lfs { int|sys||lfs_markv(fsid_t *fsidp, \
@@ -414,13 +414,13 @@
                { int|sys||fstat(int fd, struct stat12 *sb); } fstat12
 190    COMPAT_12 MODULAR compat_12 { int|sys||lstat(const char *path, \
                            struct stat12 *ub); } lstat12
-191    STD     RUMP    { long|sys||pathconf(const char *path, int name); }
-192    STD     RUMP    { long|sys||fpathconf(int fd, int name); }
+191    STD     RUMP    { long|sys||pathconf(const char *path, int name); }
+192    STD     RUMP    { long|sys||fpathconf(int fd, int name); }
 193    STD     RUMP    { int|sys||getsockopt2(int s, int level, int name, \
                            void *val, socklen_t *avalsize); }
-194    STD     RUMP    { int|sys||getrlimit(int which, \
+194    STD     RUMP    { int|sys||getrlimit(int which, \
                            struct rlimit *rlp); }
-195    STD     RUMP    { int|sys||setrlimit(int which, \
+195    STD     RUMP    { int|sys||setrlimit(int which, \
                            const struct rlimit *rlp); }
 196    COMPAT_12 MODULAR compat_12     \
                { int|sys||getdirentries(int fd, char *buf, \
@@ -429,12 +429,12 @@
                            int flags, int fd, long PAD, off_t pos); }
 198    INDIR           { quad_t|sys||__syscall(quad_t code, \
                            ... register_t args[SYS_MAXSYSARGS]); }
-199    STD      RUMP   { off_t|sys||lseek(int fd, int PAD, off_t offset, \
+199    STD     RUMP    { off_t|sys||lseek(int fd, int PAD, off_t offset, \
                            int whence); }
-200    STD      RUMP   { int|sys||truncate(const char *path, int PAD, \
+200    STD     RUMP    { int|sys||truncate(const char *path, int PAD, \
                            off_t length); }
-201    STD      RUMP   { int|sys||ftruncate(int fd, int PAD, off_t length); }
-202    STD      RUMP   { int|sys||__sysctl(const int *name, u_int namelen, \
+201    STD     RUMP    { int|sys||ftruncate(int fd, int PAD, off_t length); }
+202    STD     RUMP    { int|sys||__sysctl(const int *name, u_int namelen, \
                            void *oldv, size_t *oldlenp, const void *newv, \
                            size_t newlen); }
 203    STD             { int|sys||mlock(const void *addr, size_t len); }
@@ -442,9 +442,9 @@
 205    STD             { int|sys||undelete(const char *path); }
 206    COMPAT_50 MODULAR compat_50 RUMP { int|sys||futimes(int fd, \
                            const struct timeval50 *tptr); }
-207    STD      RUMP   { pid_t|sys||getpgid(pid_t pid); }
-208    STD      RUMP   { int|sys||reboot(int opt, char *bootstr); }
-209    STD      RUMP   { int|sys||poll(struct pollfd *fds, u_int nfds, \
+207    STD     RUMP    { pid_t|sys||getpgid(pid_t pid); }
+208    STD     RUMP    { int|sys||reboot(int opt, char *bootstr); }
+209    STD     RUMP    { int|sys||poll(struct pollfd *fds, u_int nfds, \
                            int timeout); }
 ;
 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
@@ -492,22 +492,22 @@
 234    COMPAT_50 MODULAR compat_50     \



Home | Main Index | Thread Index | Old Index