Source-Changes-HG archive

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

[src/trunk]: src/sys/kern change ' \t' to '\t'



details:   https://anonhg.NetBSD.org/src/rev/50b50ebe0e28
branches:  trunk
changeset: 971054:50b50ebe0e28
user:      christos <christos%NetBSD.org@localhost>
date:      Sun Apr 12 13:37:12 2020 +0000

description:
change ' \t' to '\t'

diffstat:

 sys/kern/syscalls.master |  185 +++++++++++++++++++++++-----------------------
 1 files changed, 93 insertions(+), 92 deletions(-)

diffs (truncated from 486 to 300 lines):

diff -r 9052ddff51fc -r 50b50ebe0e28 sys/kern/syscalls.master
--- a/sys/kern/syscalls.master  Sun Apr 12 13:30:16 2020 +0000
+++ b/sys/kern/syscalls.master  Sun Apr 12 13:37:12 2020 +0000
@@ -1,4 +1,4 @@
-       $NetBSD: syscalls.master,v 1.299 2020/04/12 13:30:16 christos Exp $
+       $NetBSD: syscalls.master,v 1.300 2020/04/12 13:37:12 christos Exp $
 
 ;      @(#)syscalls.master     8.2 (Berkeley) 1/13/94
 
@@ -70,8 +70,8 @@
 
 0      INDIR           { int|sys||syscall(int code, \
                            ... register_t args[SYS_MAXSYSARGS]); }
-1      STD             { void|sys||exit(int rval); }
-2      STD             { int|sys||fork(void); }
+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, \
                            size_t nbyte); }
@@ -92,21 +92,21 @@
 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
+17     STD             { int|sys||obreak(char *nsize); } break
 18     COMPAT_20 MODULAR compat_20 { int|sys||getfsstat(struct statfs12 *buf, \
                            long bufsize, int flags); }
 19     COMPAT_43 MODULAR compat_43     \
                { long|sys||lseek(int fd, long offset, int whence); }\
                            olseek
-20     NOERR   RUMP    { pid_t|sys||getpid_with_ppid(void); } getpid
+20     NOERR   RUMP    { pid_t|sys||getpid_with_ppid(void); } getpid
 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); }
-24     NOERR   RUMP    { uid_t|sys||getuid_with_euid(void); } getuid
-25     NOERR   RUMP    { uid_t|sys||geteuid(void); }
-26     STD     MODULAR ptrace  \
+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, \
@@ -125,30 +125,30 @@
 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); }
+36     NOERR   RUMP    { void|sys||sync(void); }
+37     STD             { int|sys||kill(pid_t pid, int signum); }
 38     COMPAT_43 MODULAR compat_43     \
                { int|sys||stat(const char *path, struct stat43 *ub); } stat43
-39     NOERR   RUMP    { pid_t|sys||getppid(void); }
+39     NOERR   RUMP    { pid_t|sys||getppid(void); }
 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); }
-43     NOERR   RUMP    { gid_t|sys||getegid(void); }
-44     STD             { int|sys||profil(char *samples, size_t size, \
+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, \
                            int facs, pid_t pid); }
 46     COMPAT_13 MODULAR compat_13 { int|sys||sigaction(int signum, \
                            const struct sigaction13 *nsa, \
                            struct sigaction13 *osa); } sigaction13
-47     NOERR   RUMP    { gid_t|sys||getgid_with_egid(void); } getgid
+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); }
-51     STD             { int|sys||acct(const char *path); }
+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( \
                            const struct sigaltstack13 *nss, \
@@ -161,7 +161,7 @@
                            const char *link); }
 58     STD     RUMP    { ssize_t|sys||readlink(const char *path, char *buf, \
                            size_t count); }
-59     STD             { int|sys||execve(const char *path, \
+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); }
@@ -174,23 +174,23 @@
                { int|sys||getpagesize(void); } ogetpagesize
 65     COMPAT_12 MODULAR compat_12 { int|sys||msync(void *addr, size_t len); }
 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)?
-66     STD             { int|sys||vfork(void); }
+66     STD             { int|sys||vfork(void); }
 67     OBSOL           vread
 68     OBSOL           vwrite
-69     OBSOL           sbrk
-70     OBSOL           sstk
+69     OBSOL           sbrk
+70     OBSOL           sstk
 71     COMPAT_43 MODULAR compat_43     \
                { int|sys||mmap(void *addr, size_t len, int prot, \
                            int flags, int fd, long pos); } ommap
-72     STD             { int|sys||ovadvise(int anom); } vadvise
-73     STD             { int|sys||munmap(void *addr, size_t len); }
-74     STD             { int|sys||mprotect(void *addr, size_t len, \
+72     STD             { int|sys||ovadvise(int anom); } vadvise
+73     STD             { int|sys||munmap(void *addr, size_t len); }
+74     STD             { int|sys||mprotect(void *addr, size_t len, \
                            int prot); }
-75     STD             { int|sys||madvise(void *addr, size_t len, \
+75     STD             { int|sys||madvise(void *addr, size_t len, \
                            int behav); }
 76     OBSOL           vhangup
 77     OBSOL           vlimit
-78     STD             { int|sys||mincore(void *addr, size_t len, \
+78     STD             { int|sys||mincore(void *addr, size_t len, \
                            char *vec); }
 79     STD     RUMP    { int|sys||getgroups(int gidsetsize, \
                            gid_t *gidset); }
@@ -221,8 +221,8 @@
                { int|sys||select(int nd, fd_set *in, fd_set *ou, \
                            fd_set *ex, struct timeval50 *tv); }
 94     UNIMPL          setdopt
-95     STD     RUMP    { int|sys||fsync(int fd); }
-96     STD             { int|sys||setpriority(int which, id_t who, int prio); }
+95     STD     RUMP    { int|sys||fsync(int fd); }
+96     STD             { int|sys||setpriority(int which, id_t who, int prio); }
 97     COMPAT_30 MODULAR compat_30     \
                { int|sys||socket(int domain, int type, int protocol); }
 98     STD     RUMP    { int|sys||connect(int s, const struct sockaddr *name, \
@@ -230,7 +230,7 @@
 99     COMPAT_43 MODULAR compat_43     \
                { int|sys||accept(int s, void *name, \
                            socklen_t *anamelen); } oaccept
-100    STD             { int|sys||getpriority(int which, id_t who); }
+100    STD             { int|sys||getpriority(int which, id_t who); }
 101    COMPAT_43 MODULAR compat_43 { int|sys||send(int s, void *buf, int len, \
                            int flags); } osend
 102    COMPAT_43 MODULAR compat_43 { int|sys||recv(int s, void *buf, int len, \
@@ -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); }
@@ -351,7 +351,7 @@
                            osetdomainname
 164    COMPAT_09 MODULAR compat        \
                { int|sys||uname(struct outsname *name); } ouname
-165    STD             { int|sys||sysarch(int op, void *parms); }
+165    STD             { int|sys||sysarch(int op, void *parms); }
 166    UNIMPL
 167    UNIMPL
 168    UNIMPL
@@ -388,7 +388,7 @@
 175    COMPAT_30 MODULAR compat_30     \
                        { int|sys||ntp_gettime(struct ntptimeval30 *ntvp); }
 #if defined(NTP) || !defined(_KERNEL_OPT)
-176    STD             { int|sys||ntp_adjtime(struct timex *tp); }
+176    STD             { int|sys||ntp_adjtime(struct timex *tp); }
 #else
 176    EXCL            ntp_adjtime
 #endif
@@ -425,7 +425,7 @@
 196    COMPAT_12 MODULAR compat_12     \
                { int|sys||getdirentries(int fd, char *buf, \
                            u_int count, long *basep); }
-197    STD             { void *|sys||mmap(void *addr, size_t len, int prot, \
+197    STD             { void *|sys||mmap(void *addr, size_t len, int prot, \
                            int flags, int fd, long PAD, off_t pos); }
 198    INDIR           { quad_t|sys||__syscall(quad_t code, \
                            ... register_t args[SYS_MAXSYSARGS]); }
@@ -434,12 +434,12 @@
 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, \
+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); }
-204    STD             { int|sys||munlock(const void *addr, size_t len); }
-205    STD             { int|sys||undelete(const char *path); }
+203    STD             { int|sys||mlock(const void *addr, size_t len); }
+204    STD             { int|sys||munlock(const void *addr, size_t len); }
+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); }
@@ -508,14 +508,14 @@
                { int|sys||nanosleep(const struct timespec50 *rqtp, \
                            struct timespec50 *rmtp); }
 241    STD     RUMP    { int|sys||fdatasync(int fd); }
-242    STD             { int|sys||mlockall(int flags); }
-243    STD             { int|sys||munlockall(void); }
+242    STD             { int|sys||mlockall(int flags); }
+243    STD             { int|sys||munlockall(void); }
 244    COMPAT_50 MODULAR compat_50     \
                { int|sys||__sigtimedwait(const sigset_t *set, \
                            siginfo_t *info, struct timespec50 *timeout); }
 245    STD             { int|sys||sigqueueinfo(pid_t pid, \
                            const siginfo_t *info); }
-246    STD     RUMP    { int|sys||modctl(int cmd, void *arg); }
+246    STD     RUMP    { int|sys||modctl(int cmd, void *arg); }
 247    STD     RUMP { int|sys||_ksem_init(unsigned int value, intptr_t *idp); }
 248    STD     RUMP { int|sys||_ksem_open(const char *name, int oflag, \
                            mode_t mode, unsigned int value, intptr_t *idp); }
@@ -564,27 +564,27 @@
 269    UNIMPL
 270    STD     RUMP    { int|sys||__posix_rename(const char *from, \
                            const char *to); }
-271    STD             { int|sys||swapctl(int cmd, void *arg, int misc); }
+271    STD             { int|sys||swapctl(int cmd, void *arg, int misc); }
 272    COMPAT_30 MODULAR compat_30     \
                { int|sys||getdents(int fd, char *buf, size_t count); }
-273    STD             { int|sys||minherit(void *addr, size_t len, \
+273    STD             { int|sys||minherit(void *addr, size_t len, \
                            int inherit); }
 274    STD     RUMP    { int|sys||lchmod(const char *path, mode_t mode); }
 275    STD     RUMP    { int|sys||lchown(const char *path, uid_t uid, \
                            gid_t gid); }
 276    COMPAT_50 MODULAR compat_50 RUMP { int|sys||lutimes(const char *path, \
                            const struct timeval50 *tptr); }
-277    STD             { int|sys|13|msync(void *addr, size_t len, int flags); }
+277    STD             { int|sys|13|msync(void *addr, size_t len, int flags); }
 278    COMPAT_30 MODULAR compat_30     \
                { int|sys|13|stat(const char *path, struct stat13 *ub); }
 279    COMPAT_30 MODULAR compat_30     \
                { int|sys|13|fstat(int fd, struct stat13 *sb); }
 280    COMPAT_30 MODULAR compat_30     \
                { int|sys|13|lstat(const char *path, struct stat13 *ub); }
-281    STD             { int|sys|14|sigaltstack( \
+281    STD             { int|sys|14|sigaltstack( \
                            const struct sigaltstack *nss, \
                            struct sigaltstack *oss); }
-282    STD             { int|sys|14|vfork(void); }
+282    STD             { int|sys|14|vfork(void); }
 283    STD     RUMP    { int|sys||__posix_chown(const char *path, uid_t uid, \
                            gid_t gid); }
 284    STD     RUMP    { int|sys||__posix_fchown(int fd, uid_t uid, \
@@ -592,7 +592,7 @@
 285    STD     RUMP    { int|sys||__posix_lchown(const char *path, uid_t uid, \
                            gid_t gid); }
 286    STD     RUMP    { pid_t|sys||getsid(pid_t pid); }
-287    STD             { pid_t|sys||__clone(int flags, void *stack); }
+287    STD             { pid_t|sys||__clone(int flags, void *stack); }
 288    STD     RUMP    { int|sys||fktrace(int fd, int ops, \
                            int facs, pid_t pid); }
 289    STD     RUMP    { ssize_t|sys||preadv(int fd, \
@@ -604,11 +604,11 @@
 291    COMPAT_16 MODULAR compat_16 { int|sys|14|sigaction(int signum, \
                            const struct sigaction *nsa, \
                            struct sigaction *osa); }
-292    STD             { int|sys|14|sigpending(sigset_t *set); }
-293    STD             { int|sys|14|sigprocmask(int how, \
+292    STD             { int|sys|14|sigpending(sigset_t *set); }
+293    STD             { int|sys|14|sigprocmask(int how, \
                            const sigset_t *set, \
                            sigset_t *oset); }
-294    STD             { int|sys|14|sigsuspend(const sigset_t *set); }
+294    STD             { int|sys|14|sigsuspend(const sigset_t *set); }
 295    COMPAT_16 MODULAR compat_16     \
                { int|sys|14|sigreturn(struct sigcontext *sigcntxp); }
 296    STD     RUMP    { int|sys||__getcwd(char *bufp, size_t length); }
@@ -630,36 +630,36 @@
                { int|sys|13|shmctl(int shmid, int cmd, \
                            struct shmid_ds13 *buf); }
 304    STD     RUMP    { int|sys||lchflags(const char *path, u_long flags); }
-305    NOERR   RUMP    { int|sys||issetugid(void); }
+305    NOERR   RUMP    { int|sys||issetugid(void); }
 306    STD     RUMP    { int|sys||utrace(const char *label, void *addr, \
                                size_t len); }
-307    STD             { int|sys||getcontext(struct __ucontext *ucp); }
-308    STD             { int|sys||setcontext(const struct __ucontext *ucp); }
-309    STD             { int|sys||_lwp_create(const struct __ucontext *ucp, \
+307    STD             { int|sys||getcontext(struct __ucontext *ucp); }
+308    STD             { int|sys||setcontext(const struct __ucontext *ucp); }
+309    STD             { int|sys||_lwp_create(const struct __ucontext *ucp, \
                                u_long flags, lwpid_t *new_lwp); }
-310    STD             { int|sys||_lwp_exit(void); }
-311    STD             { lwpid_t|sys||_lwp_self(void); }
-312    STD             { int|sys||_lwp_wait(lwpid_t wait_for, \
+310    STD             { int|sys||_lwp_exit(void); }
+311    STD             { lwpid_t|sys||_lwp_self(void); }
+312    STD             { int|sys||_lwp_wait(lwpid_t wait_for, \
                                lwpid_t *departed); }
-313    STD             { int|sys||_lwp_suspend(lwpid_t target); }
-314    STD             { int|sys||_lwp_continue(lwpid_t target); }
-315    STD             { int|sys||_lwp_wakeup(lwpid_t target); }



Home | Main Index | Thread Index | Old Index