pax_global_header00006660000000000000000000000064147523444410014522gustar00rootroot0000000000000052 comment=3d21bf8151b0d1685dcd4acdb5e346caa9ea4bdd sysvinit-3.14/000077500000000000000000000000001475234444100133415ustar00rootroot00000000000000sysvinit-3.14/.gitignore000066400000000000000000000000141475234444100153240ustar00rootroot00000000000000*.o *.tar.* sysvinit-3.14/COPYING000066400000000000000000000431031475234444100143750ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. sysvinit-3.14/COPYRIGHT000066400000000000000000000017511475234444100146400ustar00rootroot00000000000000Sysvinit is Copyright (C) 1991-2004 Miquel van Smoorenburg Updated Copyright (C) 2018 Jesse Smith This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA On Debian GNU/Linux systems, the complete text of the GNU General Public License can be found in `/usr/share/common-licenses/GPL-2'. Send patches to sysvinit-devel@nongnu.org sysvinit-3.14/Makefile000066400000000000000000000030251475234444100150010ustar00rootroot00000000000000PACKAGE=sysvinit VERSION=$(shell sed -rn '1s/.*[[:blank:]]\((.*)\)[[:blank:]].*/\1/p' doc/Changelog) all install clean distclean: @rm -f $(PACKAGE)-$(VERSION).tar.xz $(PACKAGE)-$(VERSION).tar.xz.sig $(MAKE) VERSION=$(VERSION) -C man $@ $(MAKE) VERSION=$(VERSION) -C src $@ GITLOGIN=$(shell git remote -v | head -n 1 | cut -f 1 -d '@' | sed 's/origin\t//g') override TMP:=$(shell mktemp -du $(VERSION).XXXXXXXX) override TARBALL:=$(TMP)/$(PACKAGE)-$(VERSION).tar.xz override SFTPBATCH:=$(TMP)/$(VERSION)-sftpbatch SOURCES=contrib COPYING COPYRIGHT doc Makefile man README src dist: $(TARBALL).sig @cp $(TARBALL) . @cp $(TARBALL).sig . @echo "tarball $(PACKAGE)-$(VERSION).tar.xz ready" rm -rf $(TMP) upload: $(SFTPBATCH) echo @sftp -b $< $(GITLOGIN)@dl.sv.nongnu.org:/releases/$(PACKAGE) rm -rf $(TMP) $(SFTPBATCH): $(TARBALL).sig @echo progress > $@ @echo put $(TARBALL) >> $@ @echo chmod 664 $(notdir $(TARBALL)) >> $@ @echo put $(TARBALL).sig >> $@ @echo chmod 664 $(notdir $(TARBALL)).sig >> $@ @echo rm $(PACKAGE)-latest.tar.bz2 >> $@ @echo symlink $(notdir $(TARBALL)) $(PACKAGE)-latest.tar.bz2 >> $@ @echo quit >> $@ $(TARBALL).sig: $(TARBALL) @gpg -q -ba --use-agent -o $@ $< $(TARBALL): $(TMP)/$(PACKAGE)-$(VERSION) @tar --exclude=.git --owner=nobody --group=nogroup -cJf $@ -C $(TMP) $(PACKAGE)-$(VERSION) $(TMP)/$(PACKAGE)-$(VERSION): distclean @mkdir -p $(TMP)/$(PACKAGE)-$(VERSION) @cp -R $(SOURCES) $(TMP)/$(PACKAGE)-$(VERSION)/ @chmod -R a+r,u+w,og-w $@ @find $@ -type d | xargs -r chmod a+rx,u+w,og-w sysvinit-3.14/README000066400000000000000000000030031475234444100142150ustar00rootroot00000000000000README for SysV init ==================== SysV init is a classic initialization program (PID 1) for GNU/Linux and other UNIX/POSIX systems. It is designed to be small, simple and to stay out of the way. Init is the parent (or grandparent) of all other processes on the system. It kicks off the starting of other system services and can act as a parent process to services which no longer have an active parent process. SysV init uses the concept of runlevels. A runlevel is a configuration of the system which allows only a selected group of processes to exist. The processes spawned by init for each of these runlevels are defined in the /etc/inittab file. Init can be in one of eight runlevels. The runlevel is changed by the administrator running the telinit command which selects which runlevel we want to use. More information on init, runlevels and switching between them can be found in the init manual page. (See "man init".) contrib Unofficial stuff, add-on programs doc Documentation man Manual pages src Source code For instructions on building and installing SysV init, please see the "doc/Install" file. SysV init releases are signed with one of two keys, depending on the build machine. These keys are public keys A573ED5E687A40F89D30E6BE2A72EB41906F8E49 and 5A2DC686CDC5D6087D88C198351F75FA45D53656. Both of these keys can be fetched from the Savannah mirror at: https://download.savannah.nongnu.org/releases/sysvinit/ The keys are also available on the public key server https://keys.openpgp.org/ sysvinit-3.14/contrib/000077500000000000000000000000001475234444100150015ustar00rootroot00000000000000sysvinit-3.14/contrib/alexander.viro000066400000000000000000000016011475234444100176430ustar00rootroot00000000000000I proposed moving some stuff to a separate file, such as the re-exec routines. Alexander wrote: According to Alexander Viro : > As for the code separation - I think it's nice. Actually, read_inittab() > with get_part() and newFamily are also pretty separatable. Another good > set is any(), spawn(), startup(), spawn_emerg() and start_if_needed(). > BTW, fail_check();process_signals(); is equivalent to process_signal(); > fail_check();. I think that swapping them (in main loop) would be a good > idea - then we can move fail_check() into start_if_needed(). And one more > - I'ld propose to move start_if_needed to the beginning of the main loop, > as in > foo(); > while(1) { bar();foo(); > #if 0 > baz(); > #endif > } > to > while(1) { foo();bar(); > #if 0 > baz(); > #endif > } > > > What do you think about it? sysvinit-3.14/contrib/migrate-svn-git000077500000000000000000000015201475234444100177420ustar00rootroot00000000000000#!/bin/sh # # Script to migrate sysvinit project source code from subversion to git. # Used february 2018. authorsmap=$(tempfile) cat > $authorsmap < wfink = Werner Fink EOF for p in sysvinit startpar insserv; do git svn clone http://svn.savannah.nongnu.org/svn/sysvinit/$p \ --authors-file=$authorsmap \ --no-metadata \ --tags=tags \ --trunk=trunk \ --prefix=$p/ \ $p-git ( cd $p-git for tag in `git branch -r | grep "tags/" | sed "s/ $p\/tags\///"`; do git tag -a -m"Converting SVN tags" $tag refs/remotes/$p/tags/$tag done if [ "sysvinit" = "$p" ]; then remote=$p.git else remote=sysvinit/$p.git fi git remote add origin ssh://git.savannah.gnu.org:/srv/git/$remote ) done rm $authorsmap sysvinit-3.14/contrib/notify-pam-dead.patch000066400000000000000000000134051475234444100210030ustar00rootroot00000000000000Index: src/init.sample =================================================================== --- src/init.sample (revision 0) +++ src/init.sample (revision 0) @@ -0,0 +1,9 @@ +#%PAM-1.0 +# +# The PAM configuration file for /sbin/init +# Used for updating the lastlog logging file +# +auth sufficient pam_rootok.so +account include common-account +session include common-session +session requisite pam_lastlog.so silent Index: src/init.c =================================================================== --- src/init.c (revision 56) +++ src/init.c (working copy) @@ -76,6 +76,10 @@ #include "reboot.h" #include "set.h" +#ifdef USE_PAM +extern void notify_pam_dead_session(const char *id); +#endif + #ifndef SIGPWR # define SIGPWR SIGUSR2 #endif @@ -1129,6 +1133,9 @@ } dup(f); dup(f); +#ifdef USE_PAM + notify_pam_dead_session(ch->id); +#endif } /* @@ -1548,6 +1555,9 @@ INITDBG(L_VB, "Updating utmp for pid %d [id %s]", ch->pid, ch->id); ch->flags &= ~RUNNING; +#ifdef USE_PAM + notify_pam_dead_session(ch->id); +#endif if (ch->process[0] != '+') write_utmp_wtmp("", ch->id, ch->pid, DEAD_PROCESS, NULL); } @@ -2009,6 +2019,9 @@ if (ch->flags & ZOMBIE) { INITDBG(L_VB, "Child died, PID= %d", ch->pid); ch->flags &= ~(RUNNING|ZOMBIE|WAITING); +#ifdef USE_PAM + notify_pam_dead_session(ch->id); +#endif if (ch->process[0] != '+') write_utmp_wtmp("", ch->id, ch->pid, DEAD_PROCESS, NULL); } @@ -2453,6 +2466,9 @@ if (ch->flags & ZOMBIE) { INITDBG(L_VB, "Child died, PID= %d", ch->pid); ch->flags &= ~(RUNNING|ZOMBIE|WAITING); +#ifdef USE_PAM + notify_pam_dead_session(ch->id); +#endif if (ch->process[0] != '+') write_utmp_wtmp("", ch->id, ch->pid, DEAD_PROCESS, NULL); } Index: src/utmp.c =================================================================== --- src/utmp.c (revision 51) +++ src/utmp.c (working copy) @@ -34,10 +34,18 @@ #include #include +#if defined(USE_PAM) && defined(INIT_MAIN) +# include +# include +#endif + #include "init.h" #include "initreq.h" #include "paths.h" +#ifndef _PATH_DEV +# define _PATH_DEV "/dev/" +#endif #if defined(__GLIBC__) # if (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0) && defined(__powerpc__) @@ -127,9 +135,9 @@ strncpy(utmp.ut_name, user, sizeof(utmp.ut_name)); strncpy(utmp.ut_id , id , sizeof(utmp.ut_id )); strncpy(utmp.ut_line, line, sizeof(utmp.ut_line)); - - /* Put the OS version in place of the hostname */ - if (uname(&uname_buf) == 0) + + /* Put the OS version in place of the hostname */ + if (uname(&uname_buf) == 0) strncpy(utmp.ut_host, uname_buf.release, sizeof(utmp.ut_host)); #if HAVE_UPDWTMP @@ -262,3 +270,75 @@ write_wtmp(user, id, pid, type, line && line[0] ? line : oldline); } +#if defined(USE_PAM) && defined(INIT_MAIN) +static pam_handle_t *pamh = NULL; +# ifdef __GNUC__ +static int +null_conv(int num_msg, const struct pam_message **msgm, + struct pam_response **response __attribute__((unused)), + void *appdata_ptr __attribute__((unused))) +# else +static int +null_conv(int num_msg, const struct pam_message **msgm, + struct pam_response **response, void *appdata_ptr) +# endif +{ + int i; + for (i = 0; i < num_msg; i++) { + const struct pam_message *msg = msgm[i]; + if (msg == (const struct pam_message*)0) + continue; + if (msg->msg == (char*)0) + continue; + switch (msg->msg_style) { + case PAM_ERROR_MSG: + case PAM_TEXT_INFO: + initlog(L_VB, "pam_message %s", msg->msg); + default: + break; + } + } + return 0; +} +static const struct pam_conv conv = { null_conv, NULL }; +# define PAM_FAIL_CHECK(func, args...) \ + { \ + if ((pam_ret = (func)(args)) != PAM_SUCCESS) { \ + initlog(L_VB, "%s", pam_strerror(pamh, pam_ret)); \ + goto pam_error; \ + } \ + } + +void notify_pam_dead_session(const char *id) +{ + struct utmp *oldut, ut; + + setutent(); + + memset(&ut, 0, sizeof(ut)); + ut.ut_type = DEAD_PROCESS; + strncpy(ut.ut_id, id, sizeof(ut.ut_id)); + + if ((oldut = getutid(&ut)) && (oldut->ut_type == USER_PROCESS)) { + int pam_ret; + char tty[UT_LINESIZE+ strlen(_PATH_DEV) + 1]; + + if (strncmp(oldut->ut_line, _PATH_DEV, strlen(_PATH_DEV))) + snprintf(tty, sizeof(tty), _PATH_DEV "%.*s", + UT_LINESIZE, oldut->ut_line); + else + snprintf(tty, sizeof(tty), "%.*s", + UT_LINESIZE, oldut->ut_line); + + PAM_FAIL_CHECK(pam_start, "init", oldut->ut_user, &conv, &pamh); + PAM_FAIL_CHECK(pam_set_item, pamh, PAM_TTY, tty); + PAM_FAIL_CHECK(pam_set_item, pamh, PAM_RHOST, oldut->ut_host); + PAM_FAIL_CHECK(pam_close_session, pamh, PAM_SILENT); + pam_error: + pam_end(pamh, pam_ret); + } + + endutent(); +} +#endif /* USE_PAM && INIT_MAIN */ + Index: src/Makefile =================================================================== --- src/Makefile (revision 58) +++ src/Makefile (working copy) @@ -8,7 +8,7 @@ # Version: @(#)Makefile 2.85-13 23-Mar-2004 miquels@cistron.nl # -CPPFLAGS = +CPPFLAGS = -DUSE_PAM CFLAGS ?= -ansi -O2 -fomit-frame-pointer override CFLAGS += -W -Wall -D_GNU_SOURCE STATIC = @@ -79,6 +79,13 @@ endif # Additional libs for GNU libc. +ifneq ($(findstring -DUSE_PAM,$(CPPFLAGS)),) + INITLIBS += -lpam + PAMDOTD = /etc/pam.d + PAMINIT = $(PAMDOTD)/init +endif + +# Additional libs for GNU libc. ifneq ($(wildcard /usr/lib*/libcrypt.a),) SULOGINLIBS += -lcrypt endif @@ -153,6 +160,11 @@ $(STRIP) $$i ; \ $(INSTALL_EXEC) $$i $(ROOT)/usr/bin/ ; \ done +ifneq ($(findstring -DUSE_PAM,$(CPPFLAGS)),) + $(INSTALL_DIR) $(ROOT)$(PAMDOTD) + test -s $(ROOT)$(PAMINIT) || \ + $(INSTALL_DATA) init.sample $(ROOT)$(PAMINIT) +endif # $(INSTALL_DIR) $(ROOT)/etc/ # $(INSTALL_EXEC) initscript.sample $(ROOT)/etc/ ln -sf halt $(ROOT)/sbin/reboot sysvinit-3.14/contrib/sysd2v.sh000077500000000000000000000360411475234444100165760ustar00rootroot00000000000000#!/bin/sh # sysd2v v0.3 -- systemd unit to sysvinit script converter # Copyright (C) 2019 Trek http://www.trek.eu.org/devel/sysd2v # distributed under the terms of the GNU General Public License 3 nl=" " # read a systemd unit file and set variables named ini_{section}_{key} # usage: read_unit filename instance # filename service unit configuration file, '-' to read from stdin # instance instance name for template units read_unit() { filename=$1 instance=$2 if [ "$filename" != - ] then inifile_unit_name=${filename##*/} inifile_unit_name=${inifile_unit_name%.*} fi rm_comm='/^[#;]/d' concat=':l; /\\$/ { N; s/[[:space:]]*\\\n/ /; tl }' subst_inst="s/%[Ii]/$instance/g" unit=$( cat "$filename" | sed "$rm_comm" | sed "$concat;$subst_inst" ) section_list=$( printf %s "$unit" | sed -n 's/^\[\([[:alnum:]]\+\)\].*/\1/p' ) oldifs=$IFS IFS=$nl for section in $section_list do get_sect='/^\['"$section"'\]/,/^\[.\+\]/' key_list=$( printf %s "$unit" | sed -n "$get_sect"'s/^\([[:alnum:]]\+\)[[:space:]]*=.*/\1/p' | sort -u ) for key in $key_list do val=$( printf %s "$unit" | sed -n "$get_sect"'s/^'"$key"'[[:space:]]*=[[:space:]]*\(.*\)/\1/p' ) var=$( echo "${section}_$key" | tr '[:upper:]' '[:lower:]' ) eval ini_$var=\$val [ -n "$debug" ] && echo "ini_$var=$val" >&2 done done IFS=$oldifs } # read a systemd configuration value and write its prefix to stdout # usage: get_prefix val # val systemd configuration value get_prefix () { printf %s "$1" | sed -n 's/^\([-@:+!|]*\).*/\1/p'; } # read a boolean value and returns true or false # usage: is_true val # val boolean value is_true () { case "$1" in 1|[Oo][Nn]|[Tt]*|[Yy]*) true;; *) false; esac } # read systemd services list and write LSB facilities to stdout # usage: get_provides services # services list of service units get_provides () { lst= for dep in $1 do lst=${lst:+$lst }${dep%.service} done printf %s "$lst" } # read systemd units list and write LSB facilities to stdout # usage: get_depends dependencies [ignores] # dependencies list of required units # ignores facilities to ignore get_depends () { lst= for dep in $1 do d= case $dep in local-fs-pre.target) d=mountkernfs;; time-sync.target) d=\$time;; systemd-modules-load.service) d=kmod;; local-fs.target|network-pre.target) d=\$local_fs;; systemd-sysctl.service) d=procps;; network.target|network-online.target|systemd-networkd.service) d=\$network;; nss-lookup.target) d=\$named;; rpcbind.target|remote-fs-pre.target) d=\$portmap;; remote-fs.target|sysinit.target|basic.target) d=\$remote_fs;; syslog.service) d=\$syslog;; boot-complete.target|multi-user.target|default.target) d=\$all;; *.service) d=${dep%.service};; *) echo "WARNING: unsupported target '$dep'" >&2 esac ign=${2:+$2 }$lst [ -z "$ign" -o -n "${ign%%*"$d"*}" ] && lst=${lst:+$lst }$d done printf %s "$lst" } # read LSB facilities list and write runlevel to stdout # usage: get_runlevel facilities # facilities list of required facilities get_runlevel () { case $1 in *\$remote_fs*) echo 2 3 4 5;; *) echo S esac } # write a list of environment files to be executed # usage: write_env list # list files separated by newlines, with prefix (-) write_env () { oldifs=$IFS IFS=$nl for env in $1 do pre=$(get_prefix "$env") noerr= [ -n "$pre" -a -z "${pre%%*-*}" ] && noerr="[ -r ${env#$pre} ] && " printf '%s\n' "$noerr. ${env#$pre}" done IFS=$oldifs } # write an environment variable containing paths # usage: write_path name prefix list # name name of the environment variable # prefix path prefix to append directories # list paths separated by spaces or newlines write_path () { lst= for dir in $3 do lst=${lst:+$lst:}$2/$dir done [ -z "$3" ] || printf '%s=%s\n' $1 $lst } # write a list of directories to be created # usage: write_install prefix list [user [group [mode]]] # prefix path prefix to append directories # list paths separated by spaces or newlines # user user ownership # group group ownership # mode permission mode write_install () { for dir in $2 do printf ' install -d %s%s/%s || return 2\n' \ "${3:+-o $3 }${4:+-g $4 }${5:+-m $5 }" "$1" "$dir" done } # write a list of commands applying systemd executable prefixes # usage: write_commands list [run [runpriv]] # list commands separated by newlines, with prefixes (-@:+!) # run command line to run each command (nice, chrt, ...) # runpriv command line to set privileges (runuser, ...) write_commands () { oldifs=$IFS IFS=$nl for cmd in $1 do pre=$(get_prefix "$cmd") beg=$3 end=' || return 2' if [ -n "$pre" ] then [ -z "${pre%%*-*}" ] && end= [ -z "${pre%%*[+!]*}" ] && beg= [ -z "${pre%%*[@:]*}" ] && echo "WARNING: unsupported exec prefix '$pre'" >&2 fi printf ' %s\n' "$2$beg${cmd#$pre}$end" done IFS=$oldifs } # read a list of commands separated by newlines and write an override function # usage: write_function name [commands] # name function name (start_cmd, stop_cmd, ...) # commands list of commands, read from stdin if omitted write_function () { lst=${2-$(cat)} [ -n "$lst" ] || return [ "$lst" = : ] && printf "do_${1}_override () :\n\n" && return end=' true\n' [ -z "${lst%%*|| return [0-9]}" -o -z "${lst%%*|| return \$?}" ] && end= printf "do_${1}_override ()\n{\n%s\n$end}\n\n" "$lst" } # write an init-d-script file starting from the ini_* vars (see read_unit) # usage: write_init servicename instance # servicename name of the service provided # instance instance name for template units write_init () { name=$1 instance=$2 if [ "${name%@}" != "$name" ] then name=$name$instance fi daemon_pre=$(get_prefix "$ini_service_execstart") daemon=${ini_service_execstart#$daemon_pre} if [ "${daemon%%[[:space:]]*}" != "$daemon" ] then daemon_args=${daemon#*[[:space:]]} daemon=${daemon%%[[:space:]]*} fi pidfile=$ini_service_pidfile if [ -n "$ini_service_user" ] then start_args="--user $ini_service_user" [ -n "$daemon_pre" -a -z "${daemon_pre%%*[+!]*}" ] || start_args="$start_args --chuid $ini_service_user" stop_args="--user $ini_service_user" runprivstart="runuser -u $ini_service_user -- " is_true "$ini_service_permissionsstartonly" || runpriv=$runprivstart fi cls=$ini_service_ioschedulingclass pri=$ini_service_ioschedulingpriority [ -n "$cls$pri" ] && start_args="$start_args --iosched ${cls:-best-effort}${pri:+:$pri}" && run="ionice ${cls:+-c $cls }${pri:+-n $pri }" pol=$ini_service_cpuschedulingpolicy pri=$ini_service_cpuschedulingpriority [ -n "$pol$pri" ] && start_args="$start_args --procsched ${pol:-other}${pri:+:$pri}" && run="${run}chrt ${pol:+--$pol }${pri:-0} " [ -n "$ini_service_nice" ] && start_args="$start_args --nicelevel $ini_service_nice" && run="${run}nice -n $ini_service_nice " pre=$(get_prefix "$ini_service_workingdirectory") workdir=${ini_service_workingdirectory#$pre} [ "$workdir" = '~' ] && workdir=\~$ini_service_user [ -n "$workdir" ] && start_args="$start_args --chdir $workdir" && chdir="${pre}cd $workdir" if [ -z "${service_type:=$ini_service_type}" ] then if [ -n "$ini_service_busname" ] then service_type=dbus elif [ -n "$ini_service_execstart" ] then service_type=simple else service_type=oneshot fi fi if [ "$service_type" != forking ] then start_args="$start_args --background" [ -z "$pidfile" -a "$ini_service_killmode" != none ] && start_args="$start_args --make-pidfile" && pidfile="/var/run/$name-sysd2v.pid" fi if [ "$service_type" = notify ] then start_args="$start_args --notify-await" timeout=${ini_service_timeoutstartsec:-$ini_service_timeoutsec} timeout=${timeout%s} [ -n "${timeout#60}" ] && start_args="$start_args --notify-timeout $timeout" [ -n "$timeout" -a -z "${timeout%%*[^0-9]*}" ] && echo "WARNING: unsupported timeout '$timeout'" >&2 elif [ "$service_type" = dbus ] then : TODO fi signal=${ini_service_killsignal#SIG} timeout=${ini_service_timeoutstopsec:-$ini_service_timeoutsec} timeout=${timeout%s} [ -n "${signal#TERM}" -o -n "${timeout#90}" ] && stop_args="$stop_args --retry=${signal:-TERM}/${timeout:-90}/KILL/5" limitnofile=$ini_service_limitnofile [ "$limitnofile" = infinity ] && limitnofile=unlimited need_install=$ini_service_runtimedirectory need_install=$need_install$ini_service_statedirectory need_install=$need_install$ini_service_cachedirectory need_install=$need_install$ini_service_logsdirectory need_install=$need_install$ini_service_configurationdirectory need_do_start=$ini_service_execstartpre$ini_service_execstartpost need_do_start=$need_do_start$need_install execstop=$ini_service_execstop if [ "$service_type" != oneshot ] then [ "$pidfile" = "/var/run/${daemon##*/}.pid" ] && unset pidfile [ "$name" = "${daemon##*/}" ] && unset name [ -n "$daemon_args" -a -z "${daemon_args%%*[\"\\]*}" ] && echo "WARNING: DAEMON_ARGS needs to be escaped" >&2 errcheck=' || return $?' if [ -n "$daemon_pre" ] then [ -z "${daemon_pre%%*-*}" ] && errcheck= [ -z "${daemon_pre%%*[@:]*}" ] && echo "WARNING: unsupported exec prefix '$daemon_pre'" >&2 fi # TODO: test if already running before start (pretest="+do_status_cmd") [ -n "$need_do_start" -o -z "$errcheck" ] && execstart="-+do_start_cmd$errcheck" errcheck=' || return $?' [ -n "$execstop" ] && errcheck= [ -n "$execstop$ini_service_execstoppost" -a \ "$ini_service_killmode" != none ] && killstop="-do_stop_cmd$errcheck" [ -n "$timeout" -a -z "${timeout%%*[^0-9]*}" ] && echo "WARNING: unsupported timeout '$timeout'" >&2 else daemon=none pidfile=none : ${name:=SERVICE_NAME} unset daemon_args start_args stop_args execstart=$ini_service_execstart runstart=$run fi need_do_start=$need_do_start$execstart start_args=${start_args# } stop_args=${stop_args# } aliases=$(get_provides "$ini_install_alias") [ -z "$ini_unit_defaultdependencies" ] || is_true "$ini_unit_defaultdependencies" && defdep=sysinit.target req_start=$(get_depends "$ini_unit_requires $defdep") should_start=$(get_depends "$ini_unit_wants $ini_unit_after" "$req_start") default_start=$(get_runlevel "$req_start $should_start") [ "$default_start" = S ] && default_stop='0 6' || default_stop='0 1 6' [ -z "$execstop$ini_service_execstoppost" ] && [ "$service_type" = oneshot -o "$ini_service_killmode" = none ] && default_stop= [ "$default_start" = S ] && ignore=\$remote_fs start_before=$(get_depends "$ini_unit_requiredby $ini_install_wantedby $ini_unit_before" "$req_start $should_start \$all $ignore") cat < Message-Id: <25042.199704141439@stone.dcs.warwick.ac.uk> Subject: SysVinit patch To: miquels@drinkel.cistron.nl Hi. Enclosed is a patch for SysVinit that I am finding tiresome to keep updating; you might like to fold it into your official releases. It does the following: * shutdown: use /etc/shutdown.allow if an option -s is given instead of testing for a controlling tty. The tty check was inflexible and unreliable. * sulogin(8): refer to inittab(5) instead of inittab(4). * sulogin: use libc passwd/shadow functions instead of home-grown ones (there's just no point in using the special version). * shutdown/sulogin: don't rely on the username "root" -- it's the UID that counts. -zefram begin 644 initdiffs.gz M'XL(``IG43,"`^T[:U/;R+*?E5_1>&L3&\G&#Y[FD%H")/%9)U"8G-0](44) M>62KD"6M1K+7)YO_?KM[1K)DFP"[V:T]=2^5`FFFIZ??W=.C##W7A;H3@YS+ MJ1=X2;W=V#W8DN,T&8:SH+%?GC`+,\\V-S?O76:\CCWX9QI`:QO_=3N[W68; M6@<'N\_J]?K].(T!+CF.8FAUH-WI-G>Z.QU:MD>;%7]X\U;+:NT!OP(T7L&6 MO/6"'!N-7;Z"3W!=3^BY=PE2./#YV48^'M^-`\?%(9J&Q)L(7M3#R9D=!UXP MJD^$E/9(*)CKRM>O7YD#M34^U?_0UO*I>Z\3P^Z!M;>MQ$"DX>M^*R--_!KY M-DHZC.>0H0L#2,8"G'`RL8,A^%X@<,!.8.;Y/MP*I#5((`G!]GU$D4H1R\:" M!),>OGSY`E"7]-*[@&OWU75=7KL7^'X6R#36"&U>#'::C,/8DV)(6$E(0%)B M*M`4$C$!3X(?CD8(X04-Q'(UQA'\%X3Q!,F8$Z(AS,8BH,TR.>..!.0@!,[> MSFF.[`K'J_LU"_'PBI,D]NO'?E(_%3[!1S%*0@P;``,A%!7"2;R0.'0=G MX20,DCCT%4^WP@]GX(8Q3$+DS0M<(HM6-)0X2"Z0RR53)DNF1V^$!N`C$:,E MP/:^WJJ;.U9K8=?(TLG59;]^W+^JGY[UB64;:=`\6,2U$PLD)AB!'8`=17$8 MQ9Z="$`UHMJ]@+'TMD3B;)%T$OL6L324C"?"#J32EIB*>!ZB,H@4#IM:!2YA"N0B)URA:%^UGH`DL* MI+7.6#AW+!I4B.>[^A MN'$X*9@*T>0EB@99(((0NQZRF0DOUQNB"6<:)RD"N2,'Z3'_`7E6A#J2C`&) M1H(#&[V/*&=),]:9EXP5A"<38B028>23X2C?B46)872F)2ZAJAGI;4WM>"M. M@ZTTF41(5ZT!YX$_)[[SL+ M8O_O`FM=@#1+;O![7"`W/H10D1L11131K/^[OE"2+QLWBF+5]%6X^%.,?_A` M.>;<6SHYWRK''.,J%7"`*J8BJ9!,<_B$\KG$S81OSS%Y)S.!ECCHO;DZNWP'5//@\\^]?I]3.A%` M:5POQG43^PY=F*J8A1/*=4ZH]N1?*%V"ZQKOO%]2I'2*2P>3$,N%X#:-1Q9, M>%S^-(R]X$[X#0[M9(3`-/2(!C:Q:P]6243B@/4];'O6TZ%VU`E6J$ZTJ`>:Q2PT6(I'9( M1H7')R^IMOAE_=FKO;MOM?<*XF^CS[;1:;/(AT1A:/.&08A$PA$T#_-1+_PPVW4B].6,[ADV2.R>33YWVY\+$;>I^:K7W<6@M MZ?O;5J=SD(47XI!^8U1RHGF5<-[X6+7X%E1:2A[/ZCB_M1C]5-T+.W3`2075P>MSOGW]$:N)*C9&\_]#OU]#[ZT28@72]#]=28A&E M,X%2+-;_'/85C8:GY*NP7&)Z@34U3@8\&V/%4G61:EE%"5N`(K8P_M04+89! M#)/HFY^)H1<_O(#??H/"P'7PHL:$>D$J#O,E'KR$3FMY!C-459(4$,$A;,KH M$&1DFC46ZR;-9!CY1;-A+$S",TWD_RH&'C:) M-$'?K*Y3KK&PND1W!G1O@'JYOWQN[-![]]GN>NL$EZD7!DM_Q+!4%M+ MP3`U-VP7,UMFO.1>3H1I_$5?+4:9D_/W@_/^&4IUMA)EJ#S,ZPPW0ICK^)&U M?>,Z5DDEPU+R*\V8D6<;S26%9&0.5-2]T)9.&4T=U91/T;1RJJJC_`AGJYCJ M'(L2WA3I='[!JB=PYTEWU/6ZFK&S\]*&IV'6"DSQ5#PI9CTI,)EOE1_&">X99*B>.+)#A@U7- M)B'`DT7IY*O/NPU0D6(8"LD5':X/J27I<%VJ?C($O^!!V7/G%J%@&7LJQ#AT M@D9HW#X-T*ZG:$2TD^TX81HDFOQH/CT[FO=F1_/W94?SP>QH MDG68#V5'LYP=V8[^8'8TGYP=U:Y/RX[FT[*C^>CL:#XJ.V90&X.;WN#D[:7. MDN05M75P3\BB]TMC35XSGY#7S#^2U\SEO&86\YJI0F5F<\6\EIO4M_*:N9K7 MS"?E-?.[Y#5S-:^9H!E;Y#7-I8Z[.J]Q1*%S3^BNG"95J6ZK)J'.=J=KHB\&>5?B&4OS].,0#?8Y[H-TW-=F2[E!N>;2,YM8UV3+YOC*W._3VV?-636FS[>8L-H#%X"Z=G@Y/+WL55[_R]ND?4>/&%+#^8AG>E MB['J?HU:M7PK5NA3CT)NR%*[%Z6/HF93(Y=\1J=C[47#D"\*551#E\IZZ]1U MU4WUZG9-M5QQOYZZ74%KE2$U(A,V!)JB7,@GY8A.J8F1!O]<_K_$MY86Z0V!191>T?T=1[?PM1/6` M*SCW&:[S#5=PC(](U#]3']K;T-KIMMK=SNZ#KN`8[T+M"MO01`=J=EO?<(7V M-E:HA;[+MM5I9OK^P0LPSN66%SJ+[5RXN7GS_L--O_?J\OCR?VYNX.41[*XOISO6=C-S[!^P MD*4[^9.W9R<_WZ#=&JV5T7>G.SR*YX-LXN)X,/AX:E2X."/#F`TKA>G!V^/3 M\X]Z6C%6*:!]U7L_>(NSZC,&FGF6M9?^A2&?+L>/H/)3]8>:UA>T&GO0VJ^C MFNND6G@W'30JA^HP@,HXN/_P0"5A>]%Y^JHVV]JD(\^F,1#TX0`639Y]Z^>7 M3U/;3X7Z(B#A$-]@:#K8<3M8BJ2JR-W$I98F'5?1J?1+=ORC=QJ-D1E\II.6 M/@YOJ3:^\4:H&SPZ5+-[S<)XJ/Q7=?LI"6$5D#IZ>@B;6)P1>#3CQ,T=Z0T\ M4R54CB_!HI$=TN2BC;>`9)*IEOK4WMG]O#(CRU.*0>X#4JIC^K'8-UY3.S7$ MHE&&$P'Z3,37;?9P2AW'A@+<(B1D\]'LAF[D2+W<23@L3&BJ<:HT/!).*&ET MD$88_3Y@""S-#ST2<&6K-"C'PO=74*59P[.`?3%$H\OY7MEYEO"/%@D?80TD M)\:B3L'4&*L18^TQ%-E116R-X8Q%$[!J2)^UNM]Z(N`J.#'@+'*RX!4+M8R+H_8 MW-6;KHK4WU("8\"A:N'B81:$I M,RAJD[03+5O0TD42%HZ2BV"5PMWL8XD`57B_E65<8%$(<"H^EG?,6U&L#7@?)OKKPMP5@E`MT,F. M[W,I`^)1>286GQ#*.R]2+8%A&M,IDRKC+*EOZ(J!+J.8SOQJV=`97)=]$/KD M9,G\4,TM$C2M^]3:58U-A0T91,.F"1ZD"SWO4*!9S-Q;\RQ` MRF7/8GRI\EE,%(N?PDYKZI^(B2+CG.&B:O,1D?G$I@\5N-EHPX?>*30S$;,2 ME5$5XW*FDE*)!`]GVSRU%D)8'E'J+]=DO;\BZ97W5G/#0@#^6\9?]D8$TVKE[?F[,R113;:4.61S_?,WU):N9!?&*P!T M`;`T6T`]>'O6[^.P3'51K^:U"ZL.S+;5WLG_Y\%W)+AHX_>1O0KS:.+7-F3V M]ZW.P4XN_3Q,K76*0MA1]6RK6*UR<5NH*PJA.[^_5)!K8A8&+?CM-X;(OL[! MPI=C<35:L*TC[,J`^BI`W;1J[FF7FN[3=':LSO9"94_D7)7O2-``` ` end sysvinit-3.14/doc/000077500000000000000000000000001475234444100141065ustar00rootroot00000000000000sysvinit-3.14/doc/Changelog000066400000000000000000001745231475234444100157340ustar00rootroot00000000000000sysvinit (3.14) released; urgency=medium * Re-introduced DESTDIR flag in src/Makefile to assist building on Arch. * Fixed typo in init.8 manual page. * Expand process length in inittab to allow a command line 253 characters (up from 127). Expand child process structure to accomidate 253 and some buffer room for newline/NULL. * Clear buffer when reading long lines from inittab, avoids garbage left over from old lines with long commands or comments. * Drop lines which are too long from inttab conf and log warning rather than truncate. sysvinit (3.13) released; urgency=low * Adjusted manual page install location. Patch provided by Mark Hindley. sysvinit (3.12) released; urgency=low * There were instances of the ctime() function being called in multiple files without checking the return value (can be NULL) and without checking the length of the returned information. While there _should_ never be a case where ctime() fails assuming success and length of returned string isn't ideal (or future-proof). We now check the return value of ctime() in bootlogd, dowall, last, logsave, and shutdown. Where no valid value is returned we supply a dummy value (usually a space in place of the expected time stamp). We also no longer assume returned string is at least 11-16 characters. * Re-commit flexible Makefile for GoboLinux. * Make sure pty.h and sys/sysmacros.h are included when building bootlogd on systems with glibc. * Fixed typos and syntax in manual page for init.8. Edits provided by : Bjarni Ingi Gislason. * Allow setting of location of the /usr directory in src/Makefile. This is handled by the usrdir variable. * Make sure src/Makefile uses sysconfdir (/etc by default) when installing configuration files. * Fix typos and syntax in pidof manual page. sysvinit (3.11) released; urgency=low * Some escape characters were included in the inittab manual page, but not displayed by the "man" command because they were not (ironically) properly escaped. This has been fixed. * Enabled chaining commands together in the inittab file. This allows the admin to run commands like "task1 && task2" or "task2 || task2" from the inittab file. * Fix typoes in halt manual page. Fixes provided by Bjarni Ingi Gislason. * Fix typos/markdown in fstab-decode manual page. Patch provided by Bjarni Ingi Gislason. sysvinit (3.10) released; urgency=low * When the user executes "machinectl stop", systemd sends SIGRTMIN+4 to PID 1 in the container, and expects that to initiate a graceful shutdown (power-off). SysV init now catches this signal and initiates a shutdown (shutdown -hP now). - floppym provided patch to accomplish this. * Fix issue in bootlogd which could cause the service to enter an endless loop (and use too much CPU) when it is able to open a device for writing, but not actually able to write to it. This resulted in bootlogd closing and re-opening the device over and over. Now bootlogd should simply fail gracefully when it cannot write to an open file/device. * Fix formatting in shutdown.8 manual page. Cleaned up whitespace and special characters. sysvinit (3.09) released; urgency=low * Patch for man/Makefile to fix the clean recipe. Provided by Lucas Nussabaum and Mark Hindley * On Linux systems, allow reboot command to pass a message to the system firmware during the restart. This is accomplished with the -m flag. * Patch from kraj which allows hddown to compile when musl is the C library. sysvinit (3.08) released; urgency=low * floppym provided patch which causes the halt command to call "shutdown -h -H" instead of "shutdown -h" when halt is invoked without parameters. This forces the shutdown command to set the INIT_HALT variable and assume, unless other conditions apply, that the "halt" call really wants to halt the machine and INIT_HALT should be set. In other words we assume halt wants to halt unless told otherwise. Addresses downstream Gentoo bug ID 911257. * Applied a patch from floppm which adds kexec option to the halt command. * Updated halt documentation and help output to display parameters in alphabetical order. sysvinit (3.07) released; urgency=low * Fixed killall5 so that processes in the omit list are not sent any signals, including SIGSTOP. * Fixed usage message for killall5 to be more accurate. * pidof was not returning PIDs of programs which were launched using a symbolic link. (ie /tmp/sleep when /tmp/sleep links to /usr/bin/sleep). This is now fixed as we check both the realpath and symbolic path for processes. In other words, "pidof /tmp/sleep" and "pidof /usr/bin/sleep" will return the same PIDs when /tmp/sleep is a symbolic link to /usr/bin/sleep. * Fixed memory initialization error in pidof. Fix provided by Markus Fischer. * Accepted patch from Mark Hindley which avoids clearing realpath information in pidof when trying to find matching executables. sysvinit (3.06) released; urgency=low * Mark Hindley fixed typo in es.po * Mark Hindley cleaned up translation code in src/Makefile. * Drop sulogin from Debian build. Removed libcrypt-dev dependency. * Fixed pt translation pages which were failing due to mis-matched open/close tags. * Makefile now respects ROOT prefix when setting up pidof-to-killall5 symbolic link. * Removed redundant translation files from man directory. * Makefile now respects DESTDIR. User can specify either ROOT= or DESTDIR= to set install prefix. sysvinit (3.05) released; urgency=low * Helge Kreutzmann provided updated Makefile for translation of manual pages. This has been added to the man directory. * Added sys/sysmacros.h include in mountpoint.c to fix compiler errors on systems where major/minor macros were not defined. * Applied patches from Mark Hindley to clean up man page Makefile, translations and installs of new man pages. * Remove reliance on linux/fs.h as it conflicts with glibc 2.36. Patch provided by lucascars. sysvinit (3.04) released; urgency=low * Mark Hindley supplied patch to make bootlogd compile on GNU Hurd systems. Was missing major/minor macro. sysvinit (3.03) released; urgency=low * Fixed formatting in init.8 man page. Patch provided by Mark Hindley. * Fixed compile error on GNU Hurd and musl-base systems. Due to missing MAX_PATH definition. Error reported by Mark Hindly. sysvinit (3.02) released; urgency=low * Added q and Q flags to synopsis in shutdown manual page. * Applied fixes for markup and spacing in manual pages. Patch provided by Mario Blattermann. * Added translation framework (po4a) from Mario Blttermann. * Added Makefile for man/ directory. Will handle translations and substitutions. * Applied new translations for multiple languages from Mario Blattermann. * Added ability to use "@" symbol in command named in the inittab file. This treats commands as literal and does not launch a shell to interpret them. * Updated inittab manual page to include overview of symbols which trigger a shell interpretor and how to disable them using the @ symbol. * Introduced change which adds error checking in bootlogd when performing chdir(). - Provided by Alexander Vickberg * Add check for console using TIOCGDEV on Linux systems in bootlogd to make finding console more robust. - Provided by Alexander Vickberg sysvinit (3.01) released; urgency=low * Default to showing processes in the uninterruptable state (D). The -z flag no longer affects whether processes in D state are shown. The -z flag does still toggle whether zombie (Z) processes are shown. * Removed unnecessary check which is always true from init tab parsing. sysvinit (3.00) released; urgency=low * Applied patch from Matthias Schiffer which allows bootlogd to read from a wider range of consoles. The console name is already passed in from the kernel command line using "console=". We no longer filter out names as strictly but do now check to confirm the "console=" device points to a valid TTY. sysvinit (2.99) released; urgency=low * Fixed typos and missing underlines in shutdown manual page. Corrections provided by Helge Kreutzmann. sysvinit (2.98) released; urgency=low * Fixed time parsing in shutdown when there is a + in front of a 0 time offset. Commands with a positive time offset (+1) would work but +0 fails. This has been corrected by Arkadiusz Miskiewicz. sysvinit (2.97) released; urgency=low * Check $(ROOT) filesystem for libcrypt instead of a hardcoded path to /usr. Added logsave and readbootlog to list of files git ignores. - Patches provided by Petr Ovtchenkov. * Code clean-up and making sure we avoid freeing unused memory. Patch provided by David Hoyer. * Added shell script from Trek which converts systemd unit files into init.d style scripts. * Added patch from Didier Gaudin which allows init to load configuration data from files stored in /etc/inittab.d/ * Added patch from William Shipley which allows shutdown time to be specified in the format +hh:mm. This is in addition to the existing formats such as hh:mm, +m, and "now". * Fixed typos in manual pages. Submitted by Helge Kreutzmann. sysvinit (2.96) released; urgency=low [ Jesse Smith ] * Added -z command line parameter to pidof which tells pidof to try to find processes in uninterruptible (D) or zombie (Z) states. This can cause pidof to hang, but produces a more complete process list. Closes Savannah bug #56534 * Reformatted init code to make if/while logic more clear. * Cleaned up some output from readbootlog. * Added -e flag to bootlogd. When -e is used, data saved to the boot log file does not have escape characters removed. This means colour and cursor movement codes stay in the log file. The may then look nicer when read with "less -R', but may appear cluttered or out of alignment when viewed with other, plain-text tools. When -e is not used, escape characters are removed/filtered. Closes Debian bug #672361. * Make sure src/Makefile cleans up all executable files when parent Makefile calls "make clean". sysvinit (2.95) released; urgency=low [ Jesse Smith ] * Fixed various typos and control codes in manual pages. Patch provided by Bjarni Ingi Gislason. * Dropped "-f" format flag for pidof command as it could be used to print information from memory or crash pidof. Replaced flag with "-d" which allows for a custom separator to be used between listed PIDs. Patch supplied by KatolaZ. * Updated manual page to describe -h and its modifiers (-H and -P) in more detail. Should close Debian bug #374039. * Use millisecond delays in init so that shutdown can happen without a near-full-second delay after all processes have terminated. Replaced do_sleep() with do_msleep(), provided by Serge Belyshev. * Replaced hardwired sleep constants in init.c with defined constants for easy updating in the future. * Accepted patch from Luc Gommans which explains why zombie and deep sleep processes (Z and D) may be hidden from pidof. * Removed link instruction against sepol library from src/Makefile. This has no change to the resulting binary, just makes the Makefile cleaner. sysvinit (2.94) released; urgency=low [ Jesse Smith ] * When the halt command is called with the -p flag (or as poweroff) the command now passes the "-h -P" flags to shutdown. This in turn sets the INIT_HALT environment variable to POWEROFF. Assuming this value is checked by initscripts during the shutting down procedure, it should cause the system to be powered off. If halt is called without -p then the value of INIT_HALT is not set and the default action (often set in /etc/default/halt) is taken. * Removed unnecessary malloc.h includes. Memory allocation and freeing is now handled in stdlib.h * Added defines for FreeBSD to make some components compile on FreeBSD 11. * Increased the size of the kernel command line buffer in bootlogd from 256 characters to 4096. This size is defined in KERNEL_COMMAND_LENGTH for easy modification downstream. * Added logsave.c and logsave.8 manual page from e2fsprogs to make sure logsave is available to initscripts. * Updated src/Makefile to make sure bootlogd compiles with Clang. * Use defined constants for password length in sulogin. Makes it easier to update/patch later. * Minor code fixes across multiple source files to avoid buffer overflows, or uninitialized strings. * Changed the way the "when" variable is used internally in shutdown.c. It starts as a NULL pointer, then might get set as a pointer to optarg, then it might get set to point to an argv parameter, then it might have a string value copied into it, over-writing the original data. We should not risk over-writing internal variables which might get used for something else (it's rude and security risk). Set up "when" as its own buffer that has data from optargs and/or argv copied into it. * Fixed typo in init.8 manual page. * Updated text of fstab-decode to explain what the utility does. sysvinit (2.93) released; urgency=low [ Jesse Smith ] * Fixed typo in pidof which would prevent the -o (omit PID) flag from working. Fixes Debian bug ##913394. * Fixed error where pidof would not omit checking PIDs passed to it when the -o flag was used. Fixes Debian bug #913394. sysvinit (2.92) released; urgency=low [ Jesse Smith ] * The shutdown and init commands were using different default delays between sending processes SIGTERM and SIGKILL - they were 3 and 5 seconds, respectively. Unified these on 3 seconds, using a new defined value in init.h. Updated shutdown manual page to reflect the change and better explain how -t and -n flags work. Updated the init manual page with the new default value. The updated documentation resolves Debian bug #375274. * Remove PC speaker beep from shutdown process in dowall.c. Closes Debian bug #614893. Patch provided by Andreas Fackler. * Removed unused Version variable from wall.c. * Updated halt/reboot manual page to acknowledge the -i flag may not properly shut down network interfaces if the interface does not have an IP address. Addresses Debian bug #361935. * Applied patch from Daniel Povey which should allow killall5/pidof to avoid locking up if it encounters stopped or zombie processes due to broken NFS mount points. This should allow Debian bug #719273 to be closed. * Applied patch from Regid Ichira to clarify shutdown command line options. Updated manual page for shutdown. Closes Debian bug #630661. * shutdown command was setting environment variable INIT_HALT to "POWERDOWN", this should have been "POWEROFF" as specified in the manual page. Fixed code to match manual page and init scripts. Closes Debian bugs #717531 and #590895 * Added -l flag to "last" command. When used it allows "last" to display usernames longer than 8 characters long. * Added -q and -Q flags to shutdown command to make the "system is going down" message appear less often. The -q flag causes messages to only appear at the 10 minute, 5 minute and x-hour intervals. The -Q flag maintains complete silence up until the final "now" warning. * Mention GRUB as a potential boot loader in init page since LILO is rarely used anymore, outside of Slackware. * Swapped out ECHOPRT for ECHOE in stty settings when init brings up emergency console. Should make backspace-erasing characters work more naturally. Closes Debian bug #402847. * Updated src/Makefile to make sure we build all the software before attempting to install. * Removed typos from pidof manual page and killall5 page. Closes Debian bugs #815839, #905245 and #890478 * Added -f option to pidof program to allow printf style formatting. Closes Debian bug #571590 Thanks to Philipp Marek for the patch. * Added new tool (readbootlog) which will read the /var/log/boot file produced by bootlogd. The output is displayed cleaned up so there are no control characters. This avoids the need to use sed or related tools to try to clean up the contents of the log. * Added manual page for readbootlog program. Updated bootlogd page to reference it. Closes Debian bug #725123. * Updated the shutdown manual page to try to make it more clear where we are talking about an initscript called halt or the halt program. Likewise whether we are talking about the shutdown process or the specific shutdown program. Should address Debian bug #374039. * Added patch from Samuel Thibault to make project compile on Hurd branch of Debian. sysvinit (2.91) world; urgency=low [ Jesse Smith ] * Adjusted order of compile flags to make it easier for downstream to adjust optimization level. Patch provided by Matias Fonzo. Can now set optimization level in CFLAGS variable. * Added --version command line flag to display current version info. Updated manual page for init.8 to match. * Version information is now fetched and defined by the Makefile. No more need to update the version manually in the init.c source. * The init process now writes the current runlevel to /var/run/runlevel. This information can be read by the "runlevel" command as well as "halt" and "reboot". Having the information logged in /var/run/runlevel as well as the utmp file means systems without utmp (like those running the musl C library) can still check the current runlevel. This is useful when running halt/reboot as these programs want to check the runlevel. * Added patch from Walter Harms which allows pidof to run without displaying output. In this mode pidof simply returns true or false without displaying PID values. Updated manual page with new -q (quiet) mode. Added -h flag for pidof, which was recognized before, but not used. The -h flag now displays brief usage information for pidof. * Added check for kernel parameter init.autocon=1. If this exists, then init will try to open its own console. If not, then any console= parameters will be ignored. This avoids conflicts with native kernel created consoles. sysvinit (2.90) world; urgency=low [ Jesse Smith ] * Updated some comments in init.c to answer questions or remove old notes we no longer need. * Removed unneeded "count" variable in utmpdump.c. * Fixed typo in accidental wrote_wtmp_rlevel == 0 || wrote_wtmp_rlevel comparison so the latter is wrote_utmp_rlevel. * Simplified logic in mountpoint.c when testing for same device or same inode. Thanks to David Binderman for pointing out the above three issues. * When we run shutdown and then the computer is put to sleep, the shutdown command recognizes time has passed and continues its countdown taking the time lapse into consideration. This prevents longer waits if we slept past the time we should have shutdown. Accurate to the nearest minute. Closes Savannah bug #36279. * Added document article and manual page for the initctl (/run/initctl) named pipe. Makes it easier for people to communicate with and extend communication to init. * Added check that named pipe is open before trying to close it when something goes wrong or we receive SIGUSER1. Avoids potential crash if we receive SIGUSR1 while pipe is not open. * Added new signal handler for SIGUSR2. When init receives SIGUSR2 it closes (and leaves closed) the named pipe /run/initctl. This can be used to make sure init does not have any files open. However, it also means we cannot switch run levels or bring down the system. The pipe can be re-opened by sending init the SIGUSR1 signal. * Added "Fall through" comments to some switch statements where multiple approaches are tried in order to prevent warnings from GCC 7 (and newer). (Thanks to Matias Fonzo for this fix.) * Added includes on Linux for sys/sysmacros.h as the old defines in the sys/types.h file will be removed in the future. (Thanks to Matias Fonzo for this fix.) * Removed old LSM file. Added .gitignore files to avoid git tracking object files. Removed old start-stop-daemon from contrib directory. (Patches provided by Guillem Jover.) * Cleaned up most warnings generated by GCC 7 & 8. We still get some from faulty "nonstring" reports, but silencing them on GCC 8 results in more warnings on GCC 7 and Clang, so leaving them for now. * Fixed compile error on Fedora 28 where crypt() will not link due to undocumented dependency change. * Updated Makefile to make sure correct version number and correct version of files are used. Makefile was pulling from master to create tarballs with old version information when trying to create beta snapshot. * Updated version information in init.c * Updated compiler flag from -fstack-protector to -fstack-protector-strong for better protection. * Cleaned up toplevel Makefile so it stops creating unnecessary temporary directories. * Fixed typo in mountpoint.c. Patch provided by Radostin Stoyanov. sysvinit (2.89) world; urgency=low [ Jesse Smith ] * Updated mountpoint command with -p flag. The -p flag causes mountpoint to search for circular mount points. For example, if /a/b/c/d is a mount point for /a/b then the former is a valid mount point. This only works on Linux since it uses /proc/mounts. Updated manual page to match. This fix closes Savannah bug #37114. * Removed two sleep calls when we are doing sync anyway to make sure data is being written. Speeds up reboot time by about two seconds. * Fixed Clang compiler warning regarding variable data parameters to sprintf(). * Updated top-level Makefile to work with git repo instead of old svn repo. * Removed unused variables and findtty() function in bootlogd * Add checks to return code for fscanf() called in init.c. This mostly just cleans up compiler warnings. * Perform error check on setuid() call as suggested in manual page. * Fix typo in killall5.c Move initscript sample file from "src" to "doc" directory and updated Makefile to match. * Allow multiple console output When booting a kernel with multiple serial console support, or multuiple console arguments ala "console=tty1 console=ttyS0,9600" the kernel will output messages to all consoles, init however will not. It will only send output to, and accept input from, the last of the consoles. This patch fixes it. (Patch provided by Martin Buck.) * Added Patch from Debian developer Mats Erik Andersson to make ioctl work on GNU/kFreeBSD. Patches bootlogd. * Added Robert Millan's Debian patch to set TERM variable to xterm (instead of cons25) when running on GNU/kFreeBSD. * Added Robert Millan's Debian patch to use /run/initctl as the named pipe for communicating. This works around a limitation on the kFreeBSD branch which prevents us from using /dev/initctl for pipes. * Confirmed we have applied Guillem Jover's patch to make ifdown work on FreeBSD. * Confirmed we have Debian patch to fix enabling SELinux. (Credit to Petter Reinholdtsen) * Confirmed we have Debian patch to make sure utf-8 flag is not cleared from tty. (Credit to Samuel Thibault) * Confirmed we have Roger Leigh's Makefile patch to allow building with multiarch libcrypt. * Applied Justus Winter's symlink patch to make sure killall5 builds and runs on Hurd. * Confirmed we have Werner Fink's PATH_MAX patch for getting killall5 to build on Hurd. * Made sure we have Petter Reinholdtsen's patch to init.c which allows init to build on GNU/kFreeBSD despite missing VSWTC. * Dropping Debian patch to use /run/nologin instead of /etc/nologin in paths.h. Seems every distribution uses a different location. Oracle uses /etc/nologin, CentOS seems to use /var/run/nologin. We will use /etc/nologin and let distros patch to suit their own preference. * Updated halt.8 man page with corrections from Christoph Anton Mitterer. * Confirmed we have applied patch from Bjarni Ingi Gislason which fixes typo in fstab-decode man page. * Applied Debian patch to allow init to build on GNU Hurd. (Credit: Roger Leigh) * Confirmed we have Debian patch from developer Johannes Truschnigg which informs the user of field size limit. * Applied patch from Debian to the init manual page (init.8) to better address runlevels. (Author unknown) * The pidof command used to discover the correct PID of a process even if the wrong path was given. For example pidof /wrongpath/sleep would find the PID of a command run as "sleep". This bug was reported on Launchpad for Ubuntu and on Savannah. https://bugs.launchpad.net/ubuntu/+source/sysvinit/+bug/1546126 http://savannah.nongnu.org/bugs/?47196 This bug appears to have been fixed in the development branch, allowing these bugs to be tested/closed. * Confirmed Savannah bug #37114 (mountpoint does not detect mount points using --bind on same file system) still exists, but fixed in Debian and Red Hat. Considering this bug closed since distributions are using util-linux's mountpoint program and ours is no longer built/used by default. Considered importing util-linux mountpoint but that would duplicate effort and pull in a new dependency on libmount. * Problem with pidof breaks after prelink (Savannah bug #34992) fixed. Patch supplied by Dave Dykstra. * Patch to automatically spawn a getty on kernel consoles The feature is useful for developers and admins that occasionally need to boot with e.g. console=ttyS0. The built in default can be overridden via inittab for each device. An entry like "S0::off:" turns off the getty on ttyS0. characters in log file. Also makes parsing easier. This should close Savannah bug report 36528. http://savannah.nongnu.org/bugs/?36528 * Applied patches provided in Savannah bug report 49991. Fix tabs in bootlogd and avoid printing uninitialized "buf" variable when consolename() fails. [ Werner Fink ] * Do not forget room for last NULL of new environment (was local bug 35866) * Handle deleted binaries in pidof (was local bug #34992) * Allow init to delete extra environment variables (was local bug #35858) * Avoid that init double environment variables for its children (was local bug #35855) * Remove man-db tag for encoding for canonical man * Sulogin: try to detect the real device(s) used for the system console /dev/console if but only if /dev/console is used. On Linux this can be more than one device, e.g. a serial line as well as a virtual console as well as a simple printer. * Fix counting message lines in wall. Patch from Petr Lautrbach. * Fix bad printf conversion specifier in wall. Patch from Sébastien Luttringer. * Add patches from Openwall project. Thanks goes to Solar Designer. * Add code to detect the system consoles with the help of the new /proc/consoles files of linux kernel 2.6.38+ * Try to make utmpdump IPv6 valid, change based on suggestion from Navdeep Bhatia (see local bug #32429) * Fix signal and alarm handling based on the patch from Florent Viard. (was local bug #32304) * Add fix for Redhat bug #573346: last incorrectly displays IPv6 addresses (was local bug #29497) * Correct fix for Debian bug #547073: use IUTF8 flag if defined and if already set to make sure the utf-8 flag is not cleared from the tty. Patch from Samuel Thibault. * Include limits.h in killall.c to enforce definition of PATH_MAX * Fix sysvinit bug #29758 Linker invocation should not contain headers. Change based on patch from Elias Pipping. * Add fix for Debian bug #580272: use return value 1 of is_selinux_enabled() to determine if SELinux is enabled, otherwise initialize SELinux and load the policy. Patch from Petter Reinholdtsen. * Make quotes visible in example of the manual page of fstab-decode * Sulogin: enforce reconnection of stdin/stdout/stderr if a device was specified. * Sulogin: if zero is read at reading the passwd guess it's done. * Sulogin: respect byte order that is do not mix chars and ints * Shutdown: use PATH_DEFAULT as suggested by Paul Arthur in local bug #36101 * Killall5/pidof: handle strange names of executables (local bug #36252) * Sulogin: be aware the crypt(3) may fail (local bug #36313) [ Petter Reinholdtsen ] * Next release will be 2.89dsf. * Add #ifdef in bootlogd.c to avoid gcc warnings about unused variable on non-linux platforms. * Only set the VSWTC field for termios in init if it is available, to get the source building on FreeBSD. * Add some code to be able to detect programs even as user with kernel 3.0 and above * Improve message printed when signaling processes to stop. Patch from Matias A. Fonzo at the dragora project. * Rename internal functions warn() and shutdown() in the shutdown binary to avoid surprising dynamic library name resolution conflict with NSS modules. Patch from Richard Tollerton. * Try harder to find libcrypt.*, even if there is no static library available. Also look in /usr/lib/*/ for the library, to handle Debian multiarch systems. Based on patch from Andrew Gregory. * Adjust included headers to be compatible with the musl C library. Patch from Matias A. Fonzo and Dragora. * Move dovoid() macro from #ifdef__GLIBC__ to #ifdef __linux__, to match the condutions of the place where it is used. Thanks to Matias A. Fonzo for noticing. * Define _XOPEN_SOURCE when building to get crypt() from instead of using in sulogin.c, to get the source building with the musl C library. * Use sysconf(_SC_SYMLOOP_MAX) instead of MAXSYMLINKS. If sysconf returns an error, fall back to MAXSYMLINKS on platforms that define it. Fixes build on Hurd. Patch from Justus Winter and Debian. * Adjust makefile to make it easier to link all binaries statically. Patch from Matias A. Fonzo and Dragora. * Rewrite findtty() in bootlogd.c to not chance working directory, to reduce the amount of failure that can happin in that function. * Adapt bootlogd TIOCCONS call to kfreebsd. Patch from Mats Erik Andersson and Debian. * Document length limit for the process field in the inittab. Patch from Johannes Truschnigg and Debian. * Fix typo in fstab-decode(8) font escape. Patch from Bjarni Ingi Gislason and Debian. * Port ifdown.c to FreeBSD. Patch from Guillem Jover and Debian. * Drop dsf part from version number. It no longer make sense to keep. * Remove obsolete/ directory from tarball. None of it have been useful for many years. * Make it possible to specify the initctl path as a compile time define INIT_FIFO. * Use narrowly scoped file descriptor for handling opened TTY in spawn(). Patch from Michał Kulling. * Check exit code from dup() in spawn() and log error if it fail. Patch from Michał Kulling. -- Petter Reinholdtsen Sun Apr 11 11:28:55 CEST 2010 sysvinit (2.88dsf) world; urgency=low [ Petter Reinholdtsen ] * Mention new home on Savannah in README. * Revert change from Fedora/RedHat where the now obsolete command INIT_CMD_CHANGECONS was introduced. Based on feedback and patch from Bill Nottingham. * Adjust makefile to make sure the install directories are created before files are copied into them. * Simplify build rules, based on patch from Mike Frysinger and Gentoo. * Fix minor bug in optimizing of argument parsing. Based on report from jakemus on freshmeat. * Add casts to get rid of compiler warning about signed/unsigned issues. * Change tty handling in init to make sure the UTF-8 flag is not cleared on boot. Patch from Samuel Thibault. * Add Makefile in toplevel directory. * Print usage information when shutdown is used by non-root user. Patch from Mike Frysinger and Gentoo. * Sync shutdown manual page and usage information. Patch from Mike Frysinger and Gentoo. * Fix race condition in utmp writing. Patch from Gil Kloepfer via Mike Frysinger and Gentoo. * Rewrite findtty() in bootlogd to recursively search /dev/ for the correct device, to handle terminal devices for example in /dev/pty/. Patch from Debian. * Make sure bootlogd findpty() returns an error value when it fails to find a usable pty. Patch from Rob Leslie via Debian. * Make sure bootlogd fflush() every line, even if asked not to flush to disk using fdatasync(). Patch from Scott Gifford via Debian. * Add compatibility code to handle old path "/etc/powerstatus" for a while. * Include definition for MNT_DETACH which is missing in older GNU libc headers. * Do not strip binaries before installing them, to make it easier to get binaries with debug information installed. [ Werner Fink ] * Add the comment from Andrea Arcangeli about the correct place of setting the default childhandler within spawn(). * Make sure that newline is printed out for last(1) even if an utmp record entry is truncated. * Check if utmp not only exists but also is writable and delay writing out of the utmp runlevel record if utmp is not writable. * Be able to find libcrypt also on 64 bit based architectures. * Add option -w to the last command to display the full user and domain names in the output. Patch from Petr Lautrbach. * Add a manual page for utmpdump as this tool is sometimes very useful even if not intended for normal use. * Use paths.h macros for wall * Change path "/etc/powerstatus" to "/var/run/powerstatus" * Detected also removable block devices at halt/reboot to be able to flush data and send them the ATA standby command. This should avoid data loss on USB sticks and other removable block devices. * Flush block devices on halt/reboot if not done by the kernel. * Set SHELL to /bin/sh in the environmant of shutdown. * Retry to write out shutdown messages if interrupted. * pidof/killall5 - make omit pid list a dynamic one. * pidof - provide '-n' to skip stat(2) syscall on network based FS. * init - avoid compiler warnings * init - initialize console by using the macros from ttydefaults.h * init - add the possibility to ignore further interrupts from keyboard * init - add the possibility to set sane terminal line settings * sulogin - add the possibility to reset the terminal io * Fix some minor problems * init - enable is_selinux_enabled() to detect selinuxfs * Add fix for Debian bug #536574 -- Can be enabled by -DACCTON_OFF * Add helper program fstab-decode to make it easier to handle /etc/mtab content. Patch by Miloslav Trmac and Fedora. * Add fix for Debian bug #335023 - Make sure TERM is set on FreeBSD. * Add fix for Debian bug #374038 - Make it clear that shutdown -c can only cancel a waiting shutdown, not an active one. * Add note to pidof manual page about the use of readlink(2). Patch by Bill Nottingham and Fedora. * Add PAM patch contrib/notify-pam-dead.patch based on Debian bug #68621, which will add PAM support for programs spawned by init on the console like sulogin. Based on patch by Topi Miettinen. This patch is not applied by default yet while we review its usefulness. It is only helpful for session handling, as sulogin do not use and will not use a PAM conv() function. The current sulogin is able to handle DES as well as MD5, SHA, and Blowfish encrypted passwords due using getpwnam(3). * Move utmp/wtmp before the execvp() in spawn() to be sure to use the correct pid even on a controlling tty * Remaining problem is that the pid of the second fork() for getting a controlling tty isn't that reported by spawn() * Re-enable writing utmp/wtmp for boot scripts * Extend sulogin to support additional encryption algorithms * Re-enable maintenance message of sulogin * Enable the sulogin fallback password check to handle MD5, SHA, and Blowfish encrypted passwords in case of getpwnam(3) fails. * sulogin picking the SELinux context was broken. Patch by Daniel Walsh -- Petter Reinholdtsen Sun Apr 11 11:28:55 CEST 2010 sysvinit (2.87dsf) world; urgency=low * Fix typos and do minor updates in the manual pages. * Correct section of mountpoint(1). * Document -e and -t options for telinit in init(8). * Update address of FSF in the COPYRIGHT file. * Document in halt(8) that -n might not disable all syncing. Patch by Bill Nottingham and Fedora * Adjust output from "last -x". In reboot lines, print endpoint of uptime too. In shutdown lines print downtimes rather than the time between downs. Fix typo in string compare in last.c. Patch by Thomas Hood. * Improve handling of IPv6 addresses in last. Patch from Fedora. * Document last options in usage information, previously only mentioned in the manual page. * Add new option -F to last, to output full date string instead of the short form provided by default. Patch from Olaf Dabrunz and SuSe. * Adjust build rules to make sure the installed binaries are stripped. * Increase the compiler warning level when building. * Fix utmp/wtmp updating on 64-bit platforms. Patch by Bill Nottingham and Fedora. * Avoid unchecked return value from malloc() in utmpdump. Patch from Christian 'Dr. Disk' Hechelmann and Fedora. * Make sure to use execle and no execl when passing environment to the new process. Patch from RedHat. * Correct init to make sure the waiting status is preserved across re-exec. Patch from RedHat. * Correct init to avoid race condition when starting programs during boot. Patch from SuSe. * Allow 'telinit u' in runlevels 0 and 6. Patch from Thomas Hood. * Change install rules to make pidof an absolute symlink. Patch from Thomas Hood. * Improve error message from init if fork() fail. Patch found in Suse. * Add support for SE Linux capability handling. Patch from Manoj Srivastava, adjusted to avoid aborting if SE policy was loaded in the initrd with patch from Bill Nottingham and Fedora. * Add -c option to pidof for only matching processes with the same process root. Ignore -c when not running as root. Patch from Thomas Woerner and Fedora. * Adjust init to terminate argv0 with one 0 rather than two so that process name can be one character longer. Patch by Kir Kolyshkin. * Make sure bootlogd exit with non-error exit code when forking of the child successfully. * Add bootlogd option -s to make it possible to control the use of fdatasync(). Patch from Thomas Hood. * Add bootlogd option -c to tell it to create the log file if it does not exist. Patch from Thomas Hood. * Let bootlogd also look at ttyB* devices to work on HPPA. Patch from Thomas Hood. * Change init to use setenv() instead of putenv, make sure the PATH value is usable on re-exec. Patch from Thomas Hood. * Add usleep in killall5 after killing processes, to force the kernel to reschedule. Patch from SuSe. * Modify pidof to not print empty line if no pid was found. * Modify init and sulogin to fix emergency mode's tty, making sure ^C and ^Z work when booting with 'emergency' kernel option. Patch from Samuel Thibault. * Modify init to allow some time for failed opens to resolve themselves. Patch from Bill Nottingham and Fedora. * Modify init to shut down IDE, SCSI and SATA disks properly. Patches from Sebastian Reichelt, Werner Fink and SuSe. * Modify wall to use UT_LINESIZE from instead of hardcoded string lengths. Patch from SuSe. * Change wall to make halt include hostname in output. * Change killall to avoid killing init by mistake. Patch from SuSe. * Change killall5 to use the exit value to report if it found any processes to kill. Patch from Debian. * Add option -o opmitpid to killall5, to make it possible to skip some pids during shutdown. Based on patch from Colin Watson and Ubuntu. * Add references between killall5 and pidof manual pages. Patch from Debian. * Modify killall to work better with user space file system, by changing cwd to /proc when stopping and killing processes, and avoiding stat() when the value isn't used. Also, lock process pages in memory to avoid paging when user processes are stopped. Patch from Debian and Goswin von Brederlow with changes by Kel Modderman. * Change shutdown to only accept flags -H and -P with the -h flag, and document this requirement in the manual page. * Change reboot/halt to work properly when used as a login shell. Patch by Dale R. Worley and Fedora. * Let sulogin fall back to the statically linked /bin/sash if both roots shell and /bin/sh fail to execute. -- Petter Reinholdtsen Sun, 12 Jul 2009 19:58:10 +0200 sysvinit (2.86) cistron; urgency=low * Fixed up bootlogd to read /proc/cmdline. Also keep an internal linebuffer to process \r, \t and ^H. It is becoming usable. * Applied trivial OWL patches * Block signals in syslog(), since syslog() is not re-entrant (James Olin Oden , redhat bug #97534) * Minor adjustments so that sysvinit compiles on the Hurd * killall5 now skips kernel threads * Inittab entries with both 'S' and other runlevels were broken. Fix by Bryan Kadzban * Changed initreq.h to be more flexible and forwards-compatible. * You can now through /dev/initctl set environment variables in init that will be inherited by its children. For now, only variables prefixed with INIT_ can be set and the maximum is 16 variables. There's also a length limit due to the size of struct init_request, so it should be safe from abuse. * Option -P and -H to shutdown set INIT_HALT=POWERDOWN and INIT_HALT=HALT as environment variables as described above * Add "mountpoint" utility. * Slightly better algorithm in killall5.c:pidof() * Added some patches from fedora-core (halt-usage, last -t, sulogin-message, user-console) -- Miquel van Smoorenburg Fri, 30 Jul 2004 14:14:58 +0200 sysvinit (2.85) cistron; urgency=low * Add IPv6 support in last(1) * Sulogin: even if the root password is empty, ask for a password- otherwise there is no way to set a timeout. * Removed support for ioctl.save. * Turned of support for /etc/initrunlvl and /var/run/initrunlvl * Fixed warts in dowall.c ("Dmitry V. Levin" ) * Fix init.c::spawn(). The "f" variable was used both as file descriptor and waitpid(2) return code. In certain circumstances, this leads to TIOCSCTTY with wrong file descriptor (Vladimir N. Oleynik). * Fix fd leak in sulogin (Dmitry V. Levin). * More error checking in all wait() calling code (Dmitry V. Levin). * Fix argv[] initialization in spawn() (Dmitry V. Levin). * Change strncpy to strncat in most places (Dmitry V. Levin). -- Miquel van Smoorenburg Tue, 15 Apr 2003 16:37:57 +0200 sysvinit (2.84) cistron; urgency=low * Don't use /etc/initlvl interface for telinit; only use /dev/initctl, and give a clear error when that fails. * Add -i/--init command line flag to init - this tells init 'behave as system init even if you're not PID#1'. Useful for testing in chroot/jail type environments. -- Miquel van Smoorenburg Tue, 27 Nov 2001 13:10:08 +0100 sysvinit (2.83) cistron; urgency=low * Fix bug in shutdown where it didn't check correctly for a virtual console when checking /etc/shutdown.allow * Fix race condition in waitpid() [Andrea Arcangeli] * Call closelog() after openlog()/syslog() since recent libc's keep the logging fd open and that is fd#0 aka stdin. -- Miquel van Smoorenburg Tue, 2 Oct 2001 23:27:06 +0200 sysvinit (2.82) cistron; urgency=low * Print out correct version number at startup. * Fix spelling of initttab in init(8) -- Miquel van Smoorenburg Thu, 23 Aug 2001 17:50:44 +0200 sysvinit (2.81) cistron; urgency=low * Fix typo/bug in killall5/pidof, -o option failed to work since 2.79. Reformatted source code to prevent this from happening again. * shutdown.8: applied redhat manpage update * sulogin: applied redhat sysvinit-2.78-sulogin-nologin.patch * sulogin: applied redhat sysvinit-2.78-notty.patch * sulogin: applied redhat sysvinit-2.78-sigint.patch sysvinit (2.80) cistron; urgency=low * Grammar/spelling fixes in shutdown.c (Christian Steinrueck) * Don't set controlling tty for non-(sysinit,boot,single) runlevels -- Miquel van Smoorenburg Thu, 26 Jul 2001 13:26:56 +0200 sysvinit (2.79) cistron; urgency=low * New upstream version * several fixes to wall by Tim Robbins * Several extra boundary checks by Solar Designer * Make /dev/console controlling tty * Stricter checks on ownership of tty by mesg(1) * Documented and restricted -n option to wall(1) * Make it compile with glibc 2.2.2 * Document IO redirection in wall manpage (closes: #79491) * Update README (closes: #85650) * Fix init.8 manpage (closes: #75268) * Fix typo in halt(8) manpage (closes: #67875) * Check time argument of shutdown(8) for correctness (closes: #67825) * Check for stale sessions in last(1) (Chris Wolf ) -- Miquel van Smoorenburg Wed, 4 Jul 2001 15:04:36 +0200 sysvinit (2.78-2) frozen unstable; urgency=high * Change "booting" to "reloading" message at reload * Add "-z xxx" dummy command line argument (closes: #54717) -- Miquel van Smoorenburg Fri, 11 Feb 2000 12:17:54 +0100 sysvinit (2.78-1) unstable; urgency=low * 2.78 will be the new upstream version, I'm skipping 2.77 * Shutdown now calls sync before switching the runlevel to 0 or 6, or before unmounting filesystems if -n was used (closes: #46461) * Some cosmetic changes to init.c (closes: #32079) -- Miquel van Smoorenburg Thu, 30 Dec 1999 20:40:23 +0100 sysvinit (2.77-2) unstable; urgency=low * Fix last -i option -- Miquel van Smoorenburg Tue, 5 Oct 1999 21:51:50 +0200 sysvinit (2.77-1) unstable; urgency=low * Write reboot record into utmp file as well to make rms happy * Fork and dump core in / if SIGSEGV is received for debugging purposes * Patch by Craig Sanders for "last" -i option -- Miquel van Smoorenburg Wed, 4 Aug 1999 11:16:23 +0200 sysvinit (2.76-4) unstable; urgency=low * Change dowall.c to handle Unix98 ptys correctly * Add comment in rcS about usage of setup.sh and unconfigured.sh * Shutdown now removes nologin file just before calling telinit * SEGV handler now tries to continue after sleep of 30 seconds. On a 386-class processor it also prints out the value of EIP. * Fix for racecondition in check_init_fifo() by Richard Gooch -- Miquel van Smoorenburg Sat, 8 May 1999 17:22:57 +0200 sysvinit (2.76-3) frozen unstable; urgency=high * Small bugfix to last.c courtesy of Danek Duvall -- Miquel van Smoorenburg Tue, 12 Jan 1999 12:12:44 +0100 sysvinit (2.76-1) frozen unstable; urgency=high * Fix bug in check_pipe() which crashes init on the Alpha. -- Miquel van Smoorenburg Tue, 3 Nov 1998 11:09:13 +0100 sysvinit (2.75-4) unstable; urgency=low * Change sulogin password buffer to 128 characters. * Don't print control characters in dowall.c * Try to open getenv ("CONSOLE"), /dev/console and /dev/tty0 in order. For backwards compatibility when you try to boot a 2.0.x kernel with a linux > 2.1.70 /dev/console device. * Change src/Makefile for non-debian systems (mainly, RedHat) * Try to create /dev/initctl if not present; check every time to see if the dev/ino of /dev/initctl has changed and re-open it. This should help devfs a bit. * Send SIGUSR1 to init at bootup to let it re-open /dev/initctl; again in support of devfs. * Moved pidof to /bin (it's only a link to killall5 anyway) -- Miquel van Smoorenburg Mon, 5 Oct 1998 14:03:14 +0200 sysvinit (2.75-2) frozen unstable; urgency=medium * Fix last.c again. * Add check to see if /dev/initctl is really a FIFO * In ifdown.c first down all shaper devices then the real devices -- Miquel van Smoorenburg Tue, 2 Jun 1998 22:43:01 +0200 sysvinit (2.75-1) frozen unstable; urgency=low * Rewrote last.c to be much more memory friendly and correct, thanks to Nick Andrew and David Parrish * Fixes bugs: #21616: sysvinit: sulogin thinks md5 root password is bad #21765: sysvinit: Typo in `killall5.c' #21775: sysvinit: sysvinit does not support MD5 hashed passwords #21990: /usr/bin/last: unnecessary memset and off-by-one bug #22084: sysvinit 2.74-4: SIGPWR missing on sparc #21900: init, powerfail events, and shutdown.allow #21702: init 0 does not work as expected... #21728: sysvinit: Typo in `init.c' #22363: sysvinit: discrepance btw. manpage and /sbin/init -- Miquel van Smoorenburg Tue, 19 May 1998 11:02:29 +0200 sysvinit (2.74-4) frozen unstable; urgency=medium * Add -o option to last to process libc5 utmp files. * Buffer overflow fixed in init.c (not very serious; only exploitable by root). Thanks to Chris Evans -- Miquel van Smoorenburg Wed, 15 Apr 1998 17:04:33 +0200 sysvinit (2.74-1) unstable; urgency=low * Should compile with glibc 1.99 :) * Change behaviour of reboot(1) and halt(1) so that the default when the runlevel can't be determined is to call shutdown. * Added re-exec patch from Al Viro (21 Feb 1998): 'U' flag added to telinit. It forces init to re-exec itself (passing its state through exec, certainly). May be useful for smoother (heh) upgrades. 24 Feb 1998, AV: did_boot made global and added to state - thanks, Miquel. Yet another file descriptors leak - close state pipe if re_exec fails. -- Miquel van Smoorenburg Thu, 12 Mar 1998 17:42:46 +0100 sysvinit (2.73-2) unstable; urgency=low * Change _NSIG to NSIG for 2.1.x kernel includes. -- Miquel van Smoorenburg Thu, 8 Jan 1998 16:01:02 +0100 sysvinit (2.73-1) unstable; urgency=low * Use siginterrupt, now that system calls are restarted by default. Main symptom was that the sulogin timeout didn't work but there might have been more hidden problems. * Kill process immediately if turned off in inittab * Fixed sulogin check on tty arg. * Use strerror() instead of sys_errlist * wall now supports a '-n' option to suppress [most of] the banner. Debian doesn't use sysvinit's wall, but apparently Redhat does. * Add '-F' (forcefsck) option to shutdown * Close and reopen /dev/initctl on SIGUSR1 (mainly for a /dev in ram) -- Miquel van Smoorenburg Sat, 3 Jan 1998 16:32:39 +0100 sysvinit (2.72-3) unstable; urgency=low * Add extra fork() in dowall.c to avoid hanging in rare cases -- Miquel van Smoorenburg Wed, 22 Oct 1997 14:44:00 +0200 sysvinit (2.72) unstable; urgency=low * Applied manual page patches by Bill Hawes . Thanks Bill! * Applied patches to the sample Slackware scripts by "Jonathan I. Kamens" * Fix halt and reboot runlevels 0 & 6 check. * Only say "no more processes left in runlevel x" once * Fix race condition with SIGCHLD in spawn() (thanks to Alon Ziv ) * Compress all manpages (missed 2) * Compiled for libc6 * Added poweroff patch by Roderich Schupp -- Miquel van Smoorenburg Sun, 12 Oct 1997 17:20:17 +0200 sysvinit (2.71-2) frozen unstable; urgency=low * Print 2.71 instead of 2.70 on startup :) -- Miquel van Smoorenburg Mon, 5 May 1997 12:45:25 +0200 sysvinit (2.71-1) frozen unstable; urgency=high * Added code for updwtmp() in utmp.c for glibc (2.0.3) * Fixed all programs to use functions from utmp.c and getutent() * Do not try to clean up utmp in init itself (Bug#9022) * Removed sync() from main loop. * Hopefully fixes bug #8657 (shutdown signal handling) -- Miquel van Smoorenburg Sat, 26 Apr 1997 19:57:27 +0200 sysvinit (2.70-1) unstable; urgency=low * Respawn fix * Removed StUdLy CaPs from source code * Moved files in source archive around * Fixes for glibc (utmp handling, signal handling). * Fixed '-d' option to last (now also works without '-a'). * Added extra checking in last.c to prevent showing dead entries -- Miquel van Smoorenburg Fri, 7 Feb 1997 15:31:30 +0100 sysvinit (2.69-1) frozen unstable; urgency=medium * Fixed bug that can throw X in a loop (or any other app that reads from /dev/tty0) -- Miquel van Smoorenburg Sun, 1 Dec 1996 15:32:24 +0100 sysvinit (2.67-1) frozen unstable; urgency=high * Fixes problem with /dev/console being controlling terminal of some daemons * Puts copyright file in the right place -- Miquel van Smoorenburg Fri, 15 Nov 1996 12:23:33 +0100 sysvinit (2.66-1) unstable; urgency=medium * Skipped 2.65. A development 2.65 got out by accident and is apparently being used.. * Also compiles and runs with GNU libc (and on the Alpha) * Fixed dowall.c not to exit when getpwuid() fails and uid == 0. * Fixed init panic'ing on empty lines in /etc/inittab * Changed default PATH to include /usr/local/sbin * Set /dev/console as controlling terminal for sysinit,bootwait,wait,powerwait This allows using ^C to interrupt some parts of eg the boot process. * Remove old symlink in /var/log/initlvl; let init check both /var/log and /etc itself. -- Miquel van Smoorenburg Tue, 29 Oct 1996 13:46:54 +0100 2.66 29-Oct-1996 - Skipped 2.65. A development 2.65 got out by accident and is apparently being used.. - Fixed dowall.c not to exit when getpwuid() fails and uid == 0. - Fixed init panic'ing on empty lines in /etc/inittab - Changed default PATH to include /usr/local/sbin - Ported to Linux/Alpha and GNU libc. - Set /dev/console as controlling terminal for sysinit,bootwait,wait,powerwait. This allows using ^C to interrupt some parts of eg the boot process. - Remove old symlink in /var/log/initlvl; let init check both /var/log and /etc itself. 2.64 28-Jun-1996 - Init checks CONSOLE environment variable on startup (overrides /dev/console) - Init sets CONSOLE variable for all its children. - Wtmp(): when zeroing out old utmp entries, keep ut_id field - Wtmp(): try to re-use ut_id field if possible. - SetTerm(): only read from /etc/ioctl.save if written once. - Included start-stop-daemon, C version (source only). - Fixed wait() for the emergency shell. - killall5: ignore signal before doing kill(-1, pid). 2.63 14-Jun-1996 - Fixed preinst script for Debian - Fixed init.c to become init daemon if name is init.new - Fixed pidof to not return PIDs of shell scripts 2.62-2 09-Jun-1996 - Changed debian /etc/init.d/boot script to create a nologin file at boot and to remove it just before going multiuser. 2.62 31-May-1996 - Decided to release a 2.62 version with a BIG WARNING about upgrading init in it. Will send a patch to Linus for the linux/Documentation/Changes file so that 2.62 or later is mentioned as the version to upgrade to. - Added docs for Slackware 2.61-3 29-May-1996 - Fixed debian/etc/init.d/network for the lo device. - Added "-xdev" to the cd /tmp && find in debian/etc/init.d/boot - Made remove time for files in /tmp configurable. 2.61 29-Apr-1996 - Changed /etc/init.d/boot script again - Fixed problem in init.c with trailing whitespace after entries in inittab - Fixed killall5 problems - Added manpage for lastb - Added SHELL= environment variable to sulogin - Fixed sulogin & shadow problems - Added timeout option to sulogin 2.60-2 16-Apr-1996 - Fixed sulogin (didn't work if root wasn't first entry in shadow file) - Fixed mesg for systems with "tty" group (such as Debian) - Fixed nsyslog() in killall5.c 2.60 01-Apr-1996 - Fixed race condition in init.c, resulting in hanging shutdowns. Courtesy of Max Neunhoeffer . - Fixed debian/etc/init.d/boot for swapon and mdadd - Added architecture to debian.control - Added manpages for rc.boot and rc.local - Updated inittab manpage for 4-character runlevel field - Added debian replaces for bsdutils < version_without_mesg - Fixed init.c so that it also works with kernels 1.3.81 and up 2.59 10-Mar-1996 - Init logs less to syslog (suspected to hang in syslog() or openlog() ) - removed closelog() from init.c - removed time check of runlevel record in halt. - Added options to last to get hostname from ut_addr field - Added last and mesg to installation targets - rewrote /etc/init.d/boot a bit. 2.58-2 04-Jan-1996 - Changed etc/init.d/rc to do a stty onlcr - Added /var/log/initrunlvl symlink 2.58-1 31-Dec-1995 - Added the latest debian files. - Added support for 4-character id fields (if you have libc5). - Fixed pidof (in killall5) parsing of /proc/.../stat - Save restore GMT setting in /etc/init.d/boot 2.57d 03-Dec-1995 - Added sulogin - Added "-b" flag to init, gives a shell before anything else (in case the startup scripts are screwed) - Moved fastboot to /fastboot - Folded in Debian patches. - Removed old scripts - Added debian /etc/directory. 2.57c 08-Oct-1995 - Changed over to init_request (with initreq.h) - Processes no longer killed when "process" field changes, change takes effect after next respawn. 2.57b xx-Aug-1995 - Bugfix release for Debian and Slackware 3.0 2.57a 10-Jul-1995 - Fixed race condition init init.c wrt got_chld - Fixed one-off for malloc in killall5.c - Changed dowall.c - Console code: no relink to /dev/systty on CTRL-ALT-DEL) 2.57 22-May-1995 - Changed a few things here and there, didn't really document it :) 2.55 17-Jan-1995 - Added option to shutdown to run standalone. 2.54 12-Jan-1995 - Added GNU copyrigh to all *.[ch] files. - added /etc/initscript - reboot and halt now call shutdown in runlevels 1-5 - Can run from read-only root (CDROM) 2.53 10-Oct-1994 - Renamed pidof to killall5, updated all scripts to use killall5 instead of kill -1 .... - Rewrote scripts to use this, and some general changes. - Added SysV command line compatibility to shutdown. 2.52 30-Aug-1994 - Added `powerfailnow' keyword, for when UPS battery is low. - Updated `last'. - Fixed utmp handling (wrt. CLEAN_UTMP) TODO: * Make last compatible with GNU/BSD (long options?) * update powerd * remote SIGPWR broadcast? in powerd? (with priv. port) * remote shutdown 2.50 14-Feb-1994 - Ignores unknown command line arguments. - Modelled more after the "real" sysVinit - Lots of changes all over the place. (like showing runlevel in "ps" listing, logging runlevel into utmp file etc) - now using "reliable" signals instead of V7 style. - Updated all scripts. Examples are in two directories: etc (normal) and etc-sysv (sysv style scripts). - runlevel 0 = halt, 1 = single user, 6 = reboot. - added support for serial console. - updated Propaganda, manpages. - added shutdown access control. 2.4 24-May-93 - Send out the official version into the world as SysVinit-2.4.tar.z. 2.4g 15-May-93 - Changed init to really catch SIGPWR 'cause we hooked up an UPS to the Linux machine. The keyword for catching the TreeFingerSalute is now "ctrlaltdel" instead of "power{wait,fail}". 2.4a 22-Apr-93 - Fixed last to reckognize BSD style wtmp logging. - Changed init to write wtmp records that are SysV compliant but are also reckognized by the BSD last. Added a '+' option to the 'process' field of inittab, for getties that want to do their own utmp/wtmp housekeeping (kludge!). - Now accepts a runlevel on the command line, and reckognizes the 'auto' argument. (Sets the environment variable AUTOBOOT to YES) 2.2.3 24-Mar-93 - Ripped out the 'leave' action. To difficult, and unneeded. - Going single user now kills _all_ processes. - Added '-t secs' option to all commands. - This version is stable enough to post. 2.2 02-Mar-93 - Made wait()'s asynchronous - Changed whole thing to one big state machine - Now using 'pseudo levels' # & * for SYSINIT & BOOT - Added a new type of 'action', called leave. This process will be executed when the system goes from a runlevel specified in it's runlevel field to a level that's not. Nice to bring down NFS and the like. 2.1 28-Jan-93 - Fixed a bug with 'boot' and 'once'. - Check 'initdefault' for validity. - Reckognizes "single" as command line argument. - Retries execvp with 'sh -c exec ..' if command is a shell script. (shouldn't execvp do this?) - Added patches to use syslog if defined. 2.0 08-Dec-92 - Rewrote the code totally, so started with a new version number. - Dropped Minix support, this code now is Linux - specific. - With TEST switch on, this init & telinit can run standalone for test purposes. 1.3, 05-Jul-92 - Got a 386, so installed Linux. Added 'soft' reboot to be default under linux. Fixed some typos. 1.2, 16-Jun-92 - Bugreport from Michael Haardt ; removed deadlock and added 'waitpid' instead of 'wait' for SYSV. 1.1, 30-Apr-92 - Read manual wrong: there is no 'action' field called process, but all entries are of type process. Every 'process' get exec'ed by /bin/sh -c 'exec command'. - Rapidly respawning processes are caught in the act. - _SYSV support is really Linux support, done by poe@daimi.aau.dk on 25-Mar-92. 1.0, 01-Feb-92 - Initial version, very primitive for the Minix operating system. Required some mods. to the kernel. sysvinit-3.14/doc/Install000066400000000000000000000054541475234444100154470ustar00rootroot00000000000000 Install instructions for the System V style init init, shutdown, halt, reboot, wall, last, mesg, runlevel, killall5, pidof, sulogin. All programs, files and scripts in this package are covered by the GNU General Public License version 2, and copyrighted by Miquel van Smoorenburg (1991-2004) and, Jesse Smith (2018). If you are not using Debian and the debianized package, you may have to install the new init by hand if Debian is using an init system other than SysV (eg systemd). You should be able to drop the binaries into a Slackware or Devuan system, I think. The SysV init software, core programs and manual pages can be installed by running the following two commands from the top-level source directory. make sudo make install If sudo is not installed, the "make install" command may be run as the root user. Other than the GNU make utility, SysV init has few dependencies. SysV can be built on virtually any Linux system featuring the GNU C library or musl libc. A C compiler, such as the GNU Compiler Collection (GCC) or Clang is also required. On systems which want to provide translated versions of manual pages the po4a package should be installed. Here is a list of preferred directories to install the progs & manpages, this should be done for you automatically when you run "make install" as the root user, or via sudo, ie "sudo make install". wall.1, last.1, mesg.1 /usr/man/man1 inittab.5, initscript.5 /usr/man/man5 init.8, halt.8, reboot.8, shutdown.8, powerd.8, killall5.8, pidof.8, runlevel.8, sulogin.8 /usr/man/man8 init /sbin/init inittab /etc/inittab initscript.sample /etc/initscript.sample telinit a link (with ln(1) ) to init, either in /bin or in /sbin. halt /sbin/halt reboot a link to /sbin/halt in the same directory killall5 /sbin/killall5 pidof a link to /sbin/killall5 in the same directory. runlevel /sbin/runlevel shutdown /sbin/shutdown. wall /usr/bin/wall mesg /usr/bin/mesg last /usr/bin/last sulogin /sbin/sulogin bootlogd /sbin/bootlogd utmpdump don't install, it's just a debug thingy. If you already _have_ a "wall" in /bin (the SLS release had, for example) do _not_ install this version of wall. Chances are that the wall you are already using is linked to /bin/write. Either first _remove_ /bin/wall before installing the new one, or don't install the new one at all. You might want to create a file called "/etc/shutdown.allow". Read the manual page on shutdown to find out more about this. Running from a read-only file system (CDROM?): * All communication to init goes through the FIFO /run/initctl. There should be no problem using a read-only root file system If you use a Linux kernel > 1.3.66. Older kernels don't allow writing to a FIFO on a read-only file system. sysvinit-3.14/doc/Propaganda000066400000000000000000000063141475234444100161110ustar00rootroot00000000000000 Propaganda for version 2.89 of sysvinit & utilities ================================================== NOTE: If you use a standard distribution like Slackware, Devuan or Gentoo there probably is no need to upgrade. Installing sysvinit is only for those that upgrade their system by hand or for people that create Linux distributions. SysV init was probably the most widely used init package for Linux. Most distributions once used it. sysvinit 2.4 was really a good package, and it was not the need for bug fixes but the need for more features that made me work on sysvinit again. SysV init is now a Debian package. Debian source packages are not special in any way -- in fact you can just unpack and compile it on any other Linux distribution. There was a 2.50 release of sysvinit but that was not very popular- some of the included scripts broke with certain shells and other minor things like that. Unfortunately I was not able to fix this at the time because I was abroad for some time. Therefore the description below is a comparison of 2.4 and 2.58 (actually the same blurb as from the 2.50 announce but updated). Wrt 2.4, some of the code has been made simpler. Everything, from halt to reboot to single user mode is now done by shell scripts that are executed directly by init (from /etc/inittab), so shutdown does not kill processes anymore and then calls reboot - it merely does some wall's to the logged in users and then switches to runlevel 0 (halt), 1 (single user) or 6 (reboot). I have removed support for the old style scripts; the included example scripts are the Debian GNU/Linux distribution scripts. This does not mean that eg the Slackware scripts stop to work; you can probably drop this init into Slackware 3.0 without problems. Most people have an entry in inittab to run shutdown when CTRL-ALT-DEL is pressed; a feature has been added to shutdown to check if a authorized user is logged in on one of the consoles to see if a shutdown is allowed. This can be configured with an access file. Some other general changes: - utility "runlevel" to read the current and previous runlevel from /var/run/utmp (it's also shown on the command line if you do a "ps"). - unreckognized options are silently ignored (such as the infamous "ro" - mount root file system read only). - if the file /etc/initscript is present it will be used to launch all programs that init starts (so that you can set a generic umask, ulimit eg for ALL processes - see initscript.sample). - A "sulogin" program added that always asks for the root passsword before entering single user mode. - A "-b" flag to init that starts a shell at boot time before _any_ other processing. - I moved /etc/fastboot to /fastboot - wonder what that's gonna break :) - I even updated the manpages! Right, now some boring stuff you already know since it's the same as in the 2.4 release: The sysvinit package includes * a SysV compatible /sbin/init program * a telinit program (er, just a link to /sbin/init) to change runlevels * a featureful shutdown * halt and reboot to assist shutdown * a very forgiving last utility * the wall & mesg programs (not installed by default) * manpages for everything The new SysV init can be found on: https://github.com/slicer69/sysvinit sysvinit-3.14/doc/bootlogd.README000066400000000000000000000013121475234444100165730ustar00rootroot00000000000000 bootlogd: a way to capture all console output during bootup in a logfile. - bootlogd opens /dev/console and finds out what the real console is with an ioctl() if TIOCCONS is available - otherwise bootlogd tries to parse /proc/cmdline for console= kernel command line arguments - then opens the (most probable) real console - allocates a pty pair - redirects console I/O to the pty pair - then goes in a loop reading from the pty, writing to the real console and a logfile as soon as a r/w partition is available, buffering in memory until then. As soon as bootlogd exits or gets killed, the pty is closed and the redirection will be automatically undone by the kernel. So that's pretty safe. sysvinit-3.14/doc/initctl000066400000000000000000000102211475234444100154730ustar00rootroot00000000000000This document describes the communiction pipe set up by SysV init at /run/initctl. This named pipe allows programs with the proper permissions (typically programs run by root have read+write access to the pipe) to send signals to the init program (PID 1). The init manual page has, up until recently, simply stated that people wishing to understand how to send messages to init should read the init program's source code, but that is not usually practical. Messages sent to the pipe to talk to init must have a special format. This format is defined as a C structure and the technical break-down is presented here: /* * Because of legacy interfaces, "runlevel" and "sleeptime" * aren't in a separate struct in the union. * * The weird sizes are because init expects the whole * struct to be 384 bytes. */ struct init_request { int magic; /* Magic number */ int cmd; /* What kind of request */ int runlevel; /* Runlevel to change to */ int sleeptime; /* Time between TERM and KILL */ union { struct init_request_bsd bsd; char data[368]; } i; }; Let's go through the init_request structure one line at a time. The first variable, the "magic" number must be of the value 0x03091969. The init program then knows that only programs with root access which send this magic number are authorized to communicate with init. The cmd variable is a value in the range of 0-8 (currently). This cmd variable tells init what we want it to do. Here are the possible options: 1 - Set the current runlevel, specified by the runlevel variable. 2 - The power will fail soon (probably low battery) prepare to shutdown. 3 - The power is failing, do shutdown immediately. 4 - The power is okay, cancel shutdown. 6 - Set an environment variable to a value to be specified in the data variable of this structure. Other cmd options may be added to init later. For example, command values 0, 5 and 7 are defined but currently not implemented. The runlevel variable will specify the runlevel to switch to (0-6). The sleeptime variable is to be used when we want to tell init to change the time spent waiting between sending SIGTERM and SIGKILL during the shutdown process. Changing this at run time is not yet implemented. The data variable (in the union) can be used to pass misc data which init might need to process our request. For example, when setting environment variables. When setting an environment variable through init's /run/initctl pipe, the data variable should have the format VARIABLE=VALUE. The string should be terminated with a NULL '\0' character. The following C code example shows how to send a set environment variable request to the init process using the /run/initctl pipe. This example is simplified and skips the error checking. A more comlpete example can be found in the shutdown.c program's init_setnv() function. struct init_request request; /* this is the structure defined above */ int fd; /* file descriptor for the pipe */ memset(&request, 0, sizeof(request)); /* initialize structure */ request.magic = 0x03091969; /* this magic number must be included */ request.cmd = 6; /* 6 is the command to set a variable */ sprintf(request.data, "VARIABLE=VALUE"); /* set VARIABLE to VALUE in init */ if ((fd = open(INIT_FIFO, O_WRONLY)) >= 0) /* open pipe for writing */ { size_t s = sizeof(request); /* size of the structure to write */ void *ptr = &request; /* temporary pointer */ write(fd, ptr, s); /* send the structure to the pipe */ close(fd); /* close the pipe when done */ } Usually the /run/initctl pipe would only be used by low-level programs to request a power-related shutdown or change the runlevel, like telinit would do. Most of the time there is no need to talk to init directly, but this gives us an extenable approach so init can be taught how to learn more commands. sysvinit-3.14/doc/initscript.sample000077500000000000000000000013021475234444100175000ustar00rootroot00000000000000# # initscript If this script is intalled as /etc/initscript, # it is executed by init(8) for every program it # wants to spawn like this: # # /bin/sh /etc/initscript # # It can be used to set the default umask and ulimit # of all processes. By default this script is installed # as /etc/initscript.sample, so to enable it you must # rename this script first to /etc/initscript. # # Version: @(#)initscript 1.10 10-Dec-1995 MvS. # # Author: Miquel van Smoorenburg, # # Set umask to safe level, and enable core dumps. umask 022 ulimit -c 2097151 PATH=/bin:/sbin:/usr/bin:/usr/sbin export PATH # Execute the program. eval exec "$4" sysvinit-3.14/man/000077500000000000000000000000001475234444100141145ustar00rootroot00000000000000sysvinit-3.14/man/Makefile000066400000000000000000000015341475234444100155570ustar00rootroot00000000000000MANPAGES=bootlogd.8 fstab-decode.8 halt.8 init.8 initctl.5 initscript.5 inittab.5 \ killall5.8 last.1 lastb.1 logsave.8 mesg.1 mountpoint.1 pidof.8 poweroff.8 \ readbootlog.1 reboot.8 runlevel.8 shutdown.8 sulogin.8 telinit.8 utmpdump.1 \ wall.1 PO4A := $(shell command -v po4a 2> /dev/null) PO4A_OPTS = --previous --srcdir po/ --destdir ./ --no-backups --stamp \ --package-name sysvinit --package-version $(VERSION) \ --msgid-bugs-address "Jesse " all: sed --in-place=.orig --separate 's/\@VERSION\@/$(VERSION)/g' $(MANPAGES) ifdef PO4A po4a $(PO4A_OPTS) po/po4a.cfg else @echo 'Install po4a to build translated manpages' endif # Installation recipes are in ../src/Makefile install: all clean distclean: ifdef PO4A po4a $(PO4A_OPTS) --rm-translations po/po4a.cfg endif rm -f *.po sysvinit-man.pot sysvinit-3.14/man/bootlogd.8000066400000000000000000000065261475234444100160270ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2003 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .TH BOOTLOGD 8 "Jul 21, 2003" "sysvinit " "Linux System Administrator's Manual" .SH NAME bootlogd \- record boot messages .SH SYNOPSIS .B /sbin/bootlogd .RB [ \-c ] .RB [ \-d ] .RB [ \-e ] .RB [ \-r ] .RB [ \-s ] .RB [ \-v ] .RI [ " \fB-l\fP logfile " ] .RI [ " \fB-p\fP pidfile " ] .SH DESCRIPTION \fBbootlogd\fP runs in the background and copies all strings sent to the \fI/dev/console\fP device to a logfile. If the \fIlogfile\fP is not accessible, the messages will be kept in memory until it is. .SH OPTIONS .IP \fB\-d\fP Do not fork and run in the background. .IP \fB\-e\fP Print escape characters to the boot log file. This turns off filtering of escape characters and allows tools like GNU \fBless\fP(1) to see and use colour control characters (show the log in colour). .IP \fB\-c\fP Attempt to write to the logfile even if it does not yet exist. Without this option, \fBbootlogd\fP will wait for the logfile to appear before attempting to write to it. This behavior prevents \fBbootlogd\fP from creating logfiles under mount points. .IP \fB\-r\fP If there is an existing logfile called \fIlogfile\fP rename it to \fIlogfile~\fP unless \fIlogfile~\fP already exists. .IP \fB\-s\fP Ensure that the data is written to the file after each line by calling .BR fdatasync (3). This will slow down a .BR fsck (8) process running in parallel. .IP \fB\-v\fP Show version. .IP "\fB\-l\fP \fIlogfile\fP" Log to this logfile. The default is \fI/var/log/boot\fP. .IP "\fB\-p\fP \fIpidfile\fP" Put process-id in this file. The default is no pidfile. .SH NOTES \fBbootlogd\fP saves log data which includes control characters. The log is technically a text file, but not very easy for humans to read. To address this the \fBreadbootlog\fP(1) command can be used to display the boot log without the control characters. .SH BUGS \fBbootlogd\fP works by redirecting the console output from the console device. (Consequently \fBbootlogd\fP requires PTY support in the kernel configuration.) It copies that output to the real console device and to a log file. There is no standard way of ascertaining the real console device if you have a new-style \fI/dev/console\fP device (major 5, minor 1) so \fBbootlogd\fP parses the kernel command line looking for \fBconsole=...\fP lines and deduces the real console device from that. If that syntax is ever changed by the kernel, or a console type is used that \fBbootlogd\fP does not know about then \fBbootlogd\fP will not work. .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME .SH "SEE ALSO" .BR dmesg (8), .BR fdatasync (3), .BR readbootlog (1) sysvinit-3.14/man/fstab-decode.8000066400000000000000000000046241475234444100165330ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" A man page for fstab-decode(8). .\" .\" Copyright (C) 2006 Red Hat, Inc. All rights reserved. .\" .\" This copyrighted material is made available to anyone wishing to use, .\" modify, copy, or redistribute it subject to the terms and conditions of the .\" GNU General Public License v.2. .\" .\" This program is distributed in the hope that it will be useful, but WITHOUT .\" ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or .\" FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for .\" more details. .\" .\" You should have received a copy of the GNU General Public License along .\" with this program; if not, write to the Free Software Foundation, Inc., .\" 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. .\" .\" Author: Miloslav Trmac .TH FSTAB-DECODE 8 "May 2006" "sysvinit " "Linux System Administrator's Manual" .SH NAME fstab-decode \- run a command with fstab-encoded arguments .SH SYNOPSIS .B fstab-decode .IR COMMAND " [" ARGUMENT " \&.\|.\|.\&]" .SH DESCRIPTION .B fstab-decode decodes escapes (such as newline characters and other whitespace) in the specified .IR ARGUMENT s and uses them to run .IR COMMAND . The argument escaping uses the same rules as path escaping in .IR /etc/fstab ", " /etc/mtab " and " /proc/mtab . In essence \fBfstab-decode\fR can be used anytime we want to pass multiple parameters to a command as a list of command line arguments. It turns output like this: .nf /root /mnt/remote-disk /home .fi Into one long list of parameters, "/root /mnt/remote-disk /home". This can be useful when trying to work with multiple filesystems at once. For instance, we can use it to unmount multiple NFS shares. This program also removes whitespace and other characters which might cause programs such as \fBmount\fR(8) or \fBumount\fR(8) to fail. .SH EXIT STATUS .B fstab-decode exits with status 127 if .I COMMAND can't be run. Otherwise it exits with the status returned by .IR COMMAND . .SH EXAMPLES The following example reads .IR fstab , finds all instances of VFAT filesystems and prints their mount points (argument 2 in the .I fstab file). .B fstab-decode then runs the specified program, \fBumount\fR(8), and passes it the list of VFAT mountpoints. This unmounts all VFAT partitions. .nf .B fstab-decode umount $(awk \[aq]$3 == \[dq]vfat\[dq] { print $2 }\[aq] \ /etc/fstab) .fi .SH SEE ALSO .BR fstab (5) sysvinit-3.14/man/halt.8000066400000000000000000000107631475234444100151440ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2001 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .\"{{{}}} .\"{{{ Title .TH HALT 8 "Nov 6, 2001" "sysvinit " "Linux System Administrator's Manual" .\"}}} .\"{{{ Name .SH NAME halt, reboot, poweroff \- stop the system .\"}}} .\"{{{ Synopsis .SH SYNOPSIS .B /sbin/halt .RB [ \-d ] .RB [ \-f ] .RB [ \-h ] .RB [ \-i ] .RB [ \-n ] .RB [ \-p ] .RB [ \-w ] .br .B /sbin/reboot .RB [ \-d ] .RB [ \-f ] .RB [ \-i ] .RB [ \-k ] .RB [ \-m\ ] .RB [ \-n ] .RB [ \-w ] .br .B /sbin/poweroff .RB [ \-d ] .RB [ \-f ] .RB [ \-h ] .RB [ \-i ] .RB [ \-n ] .RB [ \-w ] .\"}}} .\"{{{ Description .SH DESCRIPTION \fBhalt\fP notes that the system is being brought down in the file \fI/var/log/wtmp\fP, and then either tells the kernel to halt, reboot or power-off the system. .PP If \fBhalt\fP or \fBreboot\fP is called when the system is \fInot\fP in runlevel \fB0\fP or \fB6\fP, in other words when it's running normally, \fBshutdown\fP will be invoked instead (with the \fB\-h\fP or \fB\-r\fP flag). For more info see the \fBshutdown\fP(8) manpage. .PP The rest of this manpage describes the behavior in runlevels 0 and 6, that is when the systems shutdown scripts are being run. .\"}}} .\"{{{ Options .SH OPTIONS .IP \fB\-d\fP Don't write the wtmp record. .IP \fB\-f\fP Force halt or reboot, don't call \fBshutdown\fP(8). .IP \fB\-h\fP Put all hard drives on the system in stand-by mode just before halt or power-off. .IP \fB\-i\fP Shut down all network interfaces just before \fBhalt\fR or \fBreboot\fR. Warning: This may not work on interfaces which do not have an IP address and should ideally be handled by a network manager service. .IP \fB\-k\fP Try to reboot using \fBkexec\fP, if kernel supports it. .IP \fB\-m\fP When running on a Linux system, any quoted parameter after the \-m flag will be passed to the firmware to be interpreted at boot time. Some systems, like the Raspberry Pi, can use this to switch target partitions. Please note, this parameter enables \-f, forcing the reboot command to handle shutting down itself. .IP \fB\-n\fP Don't sync before reboot or halt. Note that the kernel and storage drivers may still sync. This implies \fB\-d\fP. .IP \fB\-p\fP When halting the system, switch off the power. This is the default when \fBhalt\fR is called as \fBpoweroff\fP. .IP \fB\-w\fP Don't actually reboot or halt but only write the wtmp record (in the \fI/var/log/wtmp\fP file). .\"}}} .\"{{{ Diagnostics .SH DIAGNOSTICS If you're not the superuser, you will get the message `must be superuser'. .\"}}} .\"{{{ Notes .SH NOTES Under older \fBsysvinit\fP releases, \fBreboot\fP and \fBhalt\fP should never be called directly. From release 2.74 on, \fBhalt\fP and \fBreboot\fP invoke \fBshutdown\fP(8) if the system is not in runlevel 0 or 6. This means that if \fBhalt\fP or \fBreboot\fP cannot find out the current runlevel (for example, when \fI/var/run/utmp\fP hasn't been initialized correctly and \fI/var/run/runlevel\fR does not exist) \fBshutdown\fP will be called, which might not be what you want. Use the \fB\-f\fP flag if you want to do a hard \fBhalt\fP or \fBreboot\fP. .PP The \fB\-h\fP flag puts all hard disks in standby mode just before halt or power-off. Right now this is only implemented for IDE drives. A side effect of putting the drive in stand-by mode is that the write cache on the disk is flushed. This is important for IDE drives, since the kernel doesn't flush the write cache itself before power-off. .PP The \fBhalt\fP program uses \fI/proc/ide/hd*\fR to find all IDE disk devices, which means that \fI/proc\fP needs to be mounted when \fBhalt\fP or \fBpoweroff\fP is called or the \fB\-h\fP switch will do nothing. .\"}}} .\"{{{ Author .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME .\"}}} .\"{{{ See also .SH "SEE ALSO" .BR shutdown (8), .BR init (8) .\"}}} sysvinit-3.14/man/init.8000066400000000000000000000326001475234444100151510ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2004 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .\"{{{}}} .\"{{{ Title .TH INIT 8 "29 Jul 2004" "sysvinit " "Linux System Administrator's Manual" .\"}}} .\"{{{ Name .SH NAME init, telinit \- process control initialization .\"}}} .\"{{{ Synopsis .SH SYNOPSIS .B /sbin/init .RB [ " \-a " ] .RB [ " \-s " ] .RB [ " \-b " ] [ \fB\-z\fP \fIxxx\fP ] .RB [ " 0123456Ss " ] .br .B /sbin/init .RB [ " \-\-version " ] .br .B /sbin/telinit [ \fB\-t\fP \fISECONDS\fP ] .RB [ " 0123456sSQqabcUu " ] .br .B /sbin/telinit [ \fB\-e\fP \fIVAR\fP[\fB=\fP\fIVAL\fP] ] .\"}}} .\"{{{ Description .SH DESCRIPTION .\"{{{ init .SS Init .B init is the parent of all processes. Its primary role is to create processes from a script stored in the file \fI/etc/inittab\fR (see \fBinittab\fR(5)). This file usually has entries which cause \fBinit\fR to spawn \fBgetty\fRs on each line that users can log in. It also controls autonomous processes required by any particular system. . .\"{{{ Runlevels .SH RUNLEVELS A \fIrunlevel\fR is a software configuration of the system which allows only a selected group of processes to exist. The processes spawned by \fBinit\fR for each of these runlevels are defined in the \fI/etc/inittab\fR file. \fBinit\fR can be in one of eight runlevels: \fB0\(en6\fP and \fBS\fP (a.k.a., \fBs\fP). The runlevel is changed by having a privileged user run \fBtelinit\fP, which sends appropriate signals to \fBinit\fP, telling it which runlevel to change to. .PP Runlevels \fBS\fP, \fB0\fP, \fB1\fP, and \fB6\fP are reserved. Runlevel S is used to initialize the system on boot. When starting runlevel S (on boot) or runlevel 1 (switching from a multi-user runlevel) the system is entering ``single-user mode'', after which the current runlevel is S. Runlevel 0 is used to halt the system; runlevel 6 is used to reboot the system. .PP After booting through S the system automatically enters one of the multi-user runlevels 2 through 5, unless there was some problem that needs to be fixed by the administrator in single-user mode. Normally after entering single-user mode the administrator performs maintenance and then reboots the system. .PP For more information, see the manpages for \fBshutdown\fP(8) and \fBinittab\fP(5). .PP Runlevels 7\(en9 are also valid, though not really documented. This is because "traditional" Unix variants don't use them. .PP Runlevels \fIS\fP and \fIs\fP are the same. Internally they are aliases for the same runlevel. .\"}}} . .SH BOOTING After \fBinit\fP is invoked as the last step of the kernel boot sequence, it looks for the file \fI/etc/inittab\fP to see if there is an entry of the type \fBinitdefault\fP (see \fBinittab\fR(5)). The \fBinitdefault\fP entry determines the initial runlevel of the system. If there is no such entry (or no \fI/etc/inittab\fR at all), a runlevel must be entered at the system console. .PP Runlevel \fBS\fP or \fBs\fP initialize the system and do not require an \fI/etc/inittab\fP file. .PP In single user mode, \fB/sbin/sulogin\fP is invoked on \fI/dev/console\fP. .PP When entering single user mode, \fBinit\fP initializes the consoles \fBstty\fP settings to sane values. Clocal mode is set. Hardware speed and handshaking are not changed. .PP When entering a multi-user mode for the first time, \fBinit\fP performs the \fBboot\fP and \fBbootwait\fP entries to allow file systems to be mounted before users can log in. Then all entries matching the runlevel are processed. .PP When starting a new process, \fBinit\fP first checks whether the file \fI/etc/initscript\fP exists. If it does, it uses this script to start the process. .PP Each time a child terminates, \fBinit\fP records the fact and the reason it died in \fI/var/run/utmp\fP and \fI/var/log/wtmp\fP, provided that these files exist. .SH CHANGING RUNLEVELS After it has spawned all of the processes specified, \fBinit\fP waits for one of its descendant processes to die, a powerfail signal, or until it is signaled by \fBtelinit\fP to change the system's runlevel. When one of the above three conditions occurs, it re-examines the \fI/etc/inittab\fP file. New entries can be added to this file at any time. However, \fBinit\fP still waits for one of the above three conditions to occur. To provide for an instantaneous response, the \fBtelinit Q\fP or \fBq\fP command can wake up \fBinit\fP to re-examine (reload) the \fI/etc/inittab\fP file. .PP If \fBinit\fP is not in single user mode and receives a powerfail signal (SIGPWR), it reads the file \fI/etc/powerstatus\fP. It then starts a command based on the contents of this file: .IP F(AIL) Power is failing, UPS is providing the power. Execute the \fBpowerwait\fP and \fBpowerfail\fP entries. .IP O(K) The power has been restored, execute the \fBpowerokwait\fP entries. .IP L(OW) The power is failing and the UPS has a low battery. Execute the \fBpowerfailnow\fP entries. .PP If \fI/etc/powerstatus\fR doesn't exist or contains anything else then the letters \fBF\fP, \fBO\fP or \fBL\fP, \fBinit\fR will behave as if it has read the letter \fBF\fP. .PP Usage of \fBSIGPWR\fP and \fI/etc/powerstatus\fP is discouraged. Someone wanting to interact with \fBinit\fP should use the \fI/run/initctl\fP control channel \(en see the \fBinitctl\fR(5) manual page for more documentation about this. .PP When \fBinit\fP is requested to change the runlevel, it sends the warning signal \fBSIGTERM\fP to all processes that are undefined in the new runlevel. It then waits 3 seconds before forcibly terminating these processes via the \fBSIGKILL\fP signal. Note that \fBinit\fP assumes that all these processes (and their descendants) remain in the same process group which \fBinit\fP originally created for them. If any process changes its process group affiliation it will not receive these signals. Such processes need to be terminated separately. .\"}}} .\"{{{ telinit .SH TELINIT \fB/sbin/telinit\fP is linked to \fB/sbin/init\fP. It takes a one-character argument and signals \fBinit\fP to perform the appropriate action. The following arguments serve as directives to \fBtelinit\fP: .IP "\fB0\fP, \fB1\fP, \fB2\fP, \fB3\fP, \fB4\fP, \fB5\fP or \fB6\fP" tell \fBinit\fP to switch to the specified run level. .IP "\fBa\fP, \fBb\fP, \fBc\fP" tell \fBinit\fP to process only those \fB/etc/inittab\fP file entries having runlevel \fBa\fP, \fBb\fP or \fBc\fP. .IP "\fBQ\fP or \fBq\fP" tell \fBinit\fP to re-examine the \fI/etc/inittab\fP file. .IP "\fBS\fP or \fBs\fP" tell \fBinit\fP to switch to single user mode. .IP "\fBU\fP or \fBu\fP" tell \fBinit\fP to re-execute itself (preserving the state). No re-examining of \fI/etc/inittab\fP file happens. Runlevel should be one of \fBSs0123456\fP otherwise request would be silently ignored. .PP \fBtelinit\fP can tell \fBinit\fP how long it should wait between sending processes the \fBSIGTERM\fR and \fBSIGKILL\fR signals. The default is 3 seconds, but this can be changed with the \fB\-t\fP option. .PP \fBtelinit \-e\fP tells \fBinit\fP to change the environment for processes it spawns. The argument of \fB\-e\fP is either of the form \fIVAR\fP=\fIVAL\fP which sets variable \fIVAR\fP to value \fIVAL\fP, or of the form \fIVAR\fP (without an equality sign) which unsets variable \fIVAR\fP. .PP \fBtelinit\fP can be invoked only by users with appropriate privileges. .PP The \fBinit\fP binary checks if it is \fBinit\fP or \fBtelinit\fP by looking at its \fIprocess id\fP; the real \fBinit\fP's process id is always \fB1\fP. \&From this it follows that instead of calling \fBtelinit\fP one can also just use \fBinit\fP instead as a shortcut. .\"}}} .\"}}} .SH ENVIRONMENT \fBInit\fP sets the following environment variables for all its children: .IP \fBPATH\fP \fI/bin:/usr/bin:/sbin:/usr/sbin\fP .IP \fBINIT_VERSION\fP As the name says. Useful to determine if a script runs directly from \fBinit\fP. .IP \fBRUNLEVEL\fP The current system runlevel. .IP \fBPREVLEVEL\fP The previous runlevel (useful after a runlevel switch). .IP \fBCONSOLE\fP The system console. This is really inherited from the kernel; however if it is not set \fBinit\fP will set it to \fI/dev/console\fP by default. .SH BOOTFLAGS It is possible to pass a number of flags to \fBinit\fP from the boot monitor (e.g., LILO or GRUB). \fBinit\fP accepts the following flags: .TP 0.5i .B \-s, S, single Single user mode boot. In this mode \fI/etc/inittab\fP is examined and the bootup rc scripts are usually run before the single user mode shell is started. . .TP 0.5i .B 1\(en5 Runlevel to boot into. . .TP 0.5i .B \-b, emergency Boot directly into a single user shell without running any other startup scripts. . .TP 0.5i .B \-a, auto The LILO boot loader adds the word "auto" to the command line if it booted the kernel with the default command line (without user intervention). If this is found \fBinit\fP sets the "AUTOBOOT" environment variable to "yes". Note that you cannot use this for any security measures \(en of course the user could specify "auto" or \fB\-a\fR on the command line manually. . .TP 0.5i .BI "\-z " xxx The argument to \fB\-z\fP is ignored. You can use this to expand the command line a bit, so that it takes some more space on the stack. \fBinit\fP can then manipulate the command line so that \fBps\fP(1) shows the current runlevel. . .TP 0.5i .B \-\-version This argument, when used on its own, displays the current version of \fBinit\fP to the console/stdout. It is a quick way to determine which \fBinit\fP software and version is being used. After the version information is displayed, \fBinit\fP immediately exits with a return code of zero. . .SH INTERFACE \fBinit\fP listens on a \fIfifo\fP as, \fI/run/initctl\fP, for messages. \fBTelinit\fP uses this to communicate with \fBinit\fP. The interface is not very well documented or finished. Those interested should study the \fIinitreq.h\fP file in the \fIsrc/\fP subdirectory of the \fBinit\fP source code tar archive. .SH SIGNALS Init reacts to several signals: .TP 0.5i .B SIGHUP Has the same effect as \fBtelinit q\fP. . .TP 0.5i .B SIGUSR1 On receipt of this signals, \fBinit\fP closes and re-opens its control fifo, \fB/run/initctl\fP. Useful for bootscripts when \fI/dev\fP is remounted. .TP 0.5i .B SIGUSR2 When \fBinit\fP receives \fBSIGUSR2\fR, \fBinit\fP closes and leaves the control fifo, \fB/run/initctl\fP, closed. This may be used to make sure \fBinit\fP is not holding open any files. However, it also prevents \fBinit\fP from switching runlevels. Which means commands like shutdown no longer work. The fifo can be re-opened by sending \fBinit\fP the \fBSIGUSR1\fR signal. .TP 0.5i .B SIGINT Normally the kernel sends this signal to \fBinit\fP when CTRL-ALT-DEL is pressed. It activates the \fIctrlaltdel\fP action. .TP 0.5i .B SIGWINCH The kernel sends this signal when the \fIKeyboardSignal\fP key is hit. It activates the \fIkbrequest\fP action. \"{{{ Conforming to .SH CONFORMING TO \fBinit\fP is compatible with the System V init. It works closely together with the scripts in the directories \fI/etc/init.d\fP and \fI/etc/rc{runlevel}.d\fP. If your system uses this convention, there should be a \fIREADME\fP file in the directory \fI/etc/init.d\fP explaining how these scripts work. .\"}}} .\"{{{ Files .SH FILES .nf /etc/inittab /etc/initscript /dev/console /var/run/utmp /var/log/wtmp /run/initctl .fi .\"}}} .\"{{{ Warnings .SH WARNINGS \fBinit\fP assumes that processes and descendants of processes remain in the same process group which was originally created for them. If the processes change their group, \fBinit\fP can't kill them and you may end up with two processes reading from one terminal line. .PP On a Debian system, entering runlevel 1 causes all processes to be killed except for kernel threads and the script that does the killing and other processes in its session. As a consequence of this, it isn't safe to return from runlevel 1 to a multi-user runlevel: daemons that were started in runlevel S and are needed for normal operation are no longer running. The system should be rebooted. .\"}}} .\"{{{ Diagnostics .SH DIAGNOSTICS If \fBinit\fP finds that it is continuously respawning an entry more than 10 times in 2 minutes, it will assume that there is an error in the command string, generate an error message on the system console, and refuse to respawn this entry until either 5 minutes has elapsed or it receives a signal. This prevents it from eating up system resources when someone makes a typographical error in the \fI/etc/inittab\fP file or the program for the entry is removed. .\"}}} .\"{{{ Author .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME , initial manual page by .MT u31b3hs@\:pool\:.informatik\:.rwth-aachen\:.de Michael Haardt .ME . .\"}}} .\"{{{ See also .SH "SEE ALSO" .BR getty (1), .BR login (1), .BR sh (1), .BR runlevel (8), .BR shutdown (8), .BR kill (1), .BR initctl (5), .BR inittab (5), .BR initscript (5), .BR utmp (5) .\"}}} sysvinit-3.14/man/initctl.5000066400000000000000000000145131475234444100156540ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 2018 Jesse Smith .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .TH INITCTL 5 "April 13, 2018" "sysvinit " "File Formats" .SH NAME initctl \- /run/initctl is a named pipe which passes commands to SysV init .SH SYNOPSIS /run/initctl .SH DESCRIPTION This document describes the communication pipe set up by SysV \fBinit\fR at \fI/run/initctl\fR. This named pipe allows programs with the proper permissions (typically programs run by root have read+write access to the pipe) to send signals to the \fBinit\fR program (PID 1). The \fBinit\fR manual page has, up until recently, simply stated that people wishing to understand how to send messages to \fBinit\fR should read the init program's source code, but that is not usually practical. Messages sent to the pipe to talk to \fBinit\fR must have a special format. This format is defined as a C structure and the technical break-down is presented here: /* * Because of legacy interfaces, "runlevel" and "sleeptime" * aren't in a separate struct in the union. * * The weird sizes are because init expects the whole * struct to be 384 bytes. */ struct init_request { int magic; /* Magic number */ int cmd; /* What kind of request */ int runlevel; /* Runlevel to change to */ int sleeptime; /* Time between TERM and KILL */ union { struct init_request_bsd bsd; char data[368]; } i; }; Let's go through the init_request structure one line at a time. The first variable, the "magic" number must be of the value 0x03091969. The \fBinit\fR program then knows that only programs with root access which send this magic number are authorized to communicate with init. The \fIcmd\fR variable is a value in the range of 0-8 (currently). This \fIcmd\fR variable tells init what we want it to do. Here are the possible options: 1 - Set the current runlevel, specified by the runlevel variable. 2 - The power will fail soon (probably low battery) prepare to shutdown. 3 - The power is failing, do shutdown immediately. 4 - The power is okay, cancel shutdown. 6 - Set an environment variable to a value to be specified in the \fIdata\fR variable of this structure. Other \fIcmd\fR options may be added to \fBinit\fR later. For example, command values 0, 5 and 7 are defined but currently not implemented. The \fIrunlevel\fR variable will specify the runlevel to switch to (0-6). The \fIsleeptime\fR variable is to be used when we want to tell \fBinit\fR to change the time spent waiting between sending \fBSIGTERM\fR and \fBSIGKILL\fR during the shutdown process. Changing this at run time is not yet implemented. The \fIdata\fR variable (in the union) can be used to pass misc data which init might need to process our request. For example, when setting environment variables. When setting an environment variable through \fBinit\fR's \fI/run/initctl\fR pipe, the data variable should have the format \fIVARIABLE\fR=\fIVALUE\fR. The string should be terminated with a NULL character. .SH EXAMPLES The following C code example shows how to send a set environment variable request to the \fBinit\fR process using the \fI/run/initctl\fR pipe. This example is simplified and skips the error checking. A more complete example can be found in the shutdown.c program's \fBinit_setnv\fR() function. .nf struct init_request request; /* structure defined above */ int fd; /* file descriptor for pipe */ memset(&request, 0, sizeof(request)); /* initialize structure */ request.magic = 0x03091969; /* magic number required */ request.cmd = 6; /* 6 is to set a variable */ sprintf(request.data, "VARIABLE=VALUE"); /* set VAR to VALUE in init */ if ((fd = open(INIT_FIFO, O_WRONLY)) >= 0) /* open pipe for writing */ { size_t s = sizeof(request); /* size of structure to write */ void *ptr = &request; /* temporary pointer */ write(fd, ptr, s); /* send structure to the pipe */ close(fd); /* close the pipe when done */ } .fi .sp .SH NOTES Usually the \fI/run/initctl\fR pipe would only be used by low-level programs to request a power-related shutdown or change the runlevel, like \fBtelinit\fR would do. Most of the time there is no need to talk to \fBinit\fR directly, but this gives us an extendable approach so \fBinit\fR can be taught how to learn more commands. .PP The commands passed through the \fI/run/initctl\fR pipe must be sent in a specific binary format and be of a specific length. Larger data structures or ones not using the proper format will be ignored. Typically, only root has the ability to write to the initctl pipe for security reasons. .PP The \fI/run/initctl\fR pipe can be closed by sending init (PID 1) the \fBSIGUSR2\fR signal. This closes the pipe and leaves it closed. This may be useful for making sure \fBinit\fR is not keeping any files open. However, when the pipe is closed, \fBinit\fR no longer receives signals, such as those sent by \fBshutdown\fR(8) or \fBtelinit\fR(8). In other words if we close the pipe, \fBinit\fR cannot change its runlevel directly. The pipe may be re-opened by sending \fBinit\fR (PID 1) the \fBSIGUSR1\fR signal. .PP If the \fI/run/initctl\fR pipe is closed then it may still be possible to bring down the system using the \fBshutdown\fR(8) command's \fB-n\fR flag, but this is not always clean and not recommended. .SH FILES /run/initctl /sbin/init .SH AUTHOR .MT jsmith@\:resonatingmedia\:.com Jesse Smith .ME .SH "SEE ALSO" .BR init (8) sysvinit-3.14/man/initscript.5000066400000000000000000000045731475234444100164030ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2003 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .TH INITSCRIPT 5 "July 10, 2003" "sysvinit " "File Formats" .SH NAME initscript \- script that executes inittab commands .SH SYNOPSIS /bin/sh /etc/initscript id runlevels action process .SH DESCRIPTION When the shell script \fI/etc/initscript\fP is present, \fBinit\fP will use it to execute the commands from \fIinittab\fP. This script can be used to set things like \fIulimit\fP and \fIumask\fP default values for every process. .SH EXAMPLES This is a sample initscript, which might be installed on your system as \fI/etc/initscript.sample\fP. .RS .sp .nf .ne 7 # # initscript Executed by init(8) for every program it # wants to spawn like this: # # /bin/sh /etc/initscript # # Set umask to safe level, and enable core dumps. umask 022 ulimit -c 2097151 PATH=/bin:/sbin:/usr/bin:/usr/sbin export PATH # Increase the hard file descriptor limit for all processes # to 8192. The soft limit is still 1024, but any unprivileged # process can increase its soft limit up to the hard limit # with "ulimit -Sn xxx" (needs a 2.2.13 or later Linux kernel). ulimit -Hn 8192 # Execute the program. eval exec "$4" .sp .RE .SH NOTES This script is not meant as startup script for daemons or services. It has nothing to do with a \fIrc.local\fP style script. It's just a handler for things executed from \fB/etc/inittab\fP. Experimenting with this can make your system un(re)bootable. .SH FILES /etc/inittab, /etc/initscript. .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME .SH "SEE ALSO" .BR inittab (5), .BR init (8) sysvinit-3.14/man/inittab.5000066400000000000000000000220601475234444100156340ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2001 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .\"{{{}}} .\"{{{ Title .TH INITTAB 5 "Dec 4, 2001" "sysvinit " "File Formats" .\"}}} .\"{{{ Name .SH NAME inittab \- format of the inittab file used by the sysv-compatible init process .\"}}} .\"{{{ Description .SH DESCRIPTION The \fBinittab\fP file describes which processes are started at bootup and during normal operation (e.g.\& /etc/init.d/boot, /etc/init.d/rc, gettys...). .BR init (8) distinguishes multiple \fIrunlevels\fP, each of which can have its own set of processes that are started. Valid runlevels are \fB0\fP\-\fB6\fP plus \fBA\fP, \fBB\fP, and \fBC\fP for \fBondemand\fP entries. An entry in the \fBinittab\fP file has the following format: .RS .sp \fIid\fP:\fIrunlevels\fP:\fIaction\fP:\fIprocess\fP .sp .RE Lines beginning with `#' are ignored. .\"{{{ id .IP \fIid\fP is a unique sequence of 1-4 characters which identifies an entry in .B inittab (for versions of sysvinit compiled with the \fIold\fP libc5 (< 5.2.18) or a.out libraries the limit is 2 characters). .sp Note: traditionally, for getty and other login processes, the value of the \fIid\fP field is kept the same as the suffix of the corresponding tty, e.g.\& \fB1\fP for \fBtty1\fP. Some ancient login accounting programs might expect this, though I can't think of any. .\"}}} .\"{{{ runlevels .IP \fIrunlevels\fP lists the runlevels for which the specified action should be taken. .\"}}} .\"{{{ action .IP \fIaction\fP describes which action should be taken. .\"}}} .\"{{{ process .IP \fIprocess\fP specifies the process to be executed. If the process field starts with a `+' character, .B init will not do utmp and wtmp accounting for that process. This is needed for gettys that insist on doing their own utmp/wtmp housekeeping. This is also a historic bug. The length of this field is limited to 253 characters. Anything beyond 253 will result in a log warning and the process command line being skipped/ignored. Please note that including certain characters in the process field will result in .B init attempting to launch a shell to interpret the command contained in the process field. The characters which will trigger a shell are: .B ~`!$^&*()=|\{}[];\ "'<>? On systems which do not have a shell to be launched or which do not wish to use a shell to interpret the process field, the process field can be prefixed with the @ symbol. The @ will be ignored and everything followed will be treated as a command to be launched, literally, by the .B init service. In cases where both a + and @ sign are to be used (to turn off logging and shell interpretation), place the + sign before the @ symbol. Both flags will be handled and then everything following the @ will be handled by .B init .\"}}} .PP The \fIrunlevels\fP field may contain multiple characters for different runlevels. For example, \fB123\fP specifies that the process should be started in runlevels 1, 2, and 3. The \fIrunlevels\fP for \fBondemand\fP entries may contain an \fBA\fP, \fBB\fP, or \fBC\fP. The \fIrunlevels\fP field of \fBsysinit\fP, \fBboot\fP, and \fBbootwait\fP entries are ignored. .PP When the system runlevel is changed, any running processes that are not specified for the new runlevel are killed, first with \s-2SIGTERM\s0, then with \s-2SIGKILL\s0. .PP Valid actions for the \fIaction\fP field are: .\"{{{ respawn .IP \fBrespawn\fP The process will be restarted whenever it terminates (e.g.\& getty). .\"}}} .\"{{{ wait .IP \fBwait\fP The process will be started once when the specified runlevel is entered and .B init will wait for its termination. .\"}}} .\"{{{ once .IP \fBonce\fP The process will be executed once when the specified runlevel is entered. .\"}}} .\"{{{ boot .IP \fBboot\fP The process will be executed during system boot. The \fIrunlevels\fP field is ignored. .\"}}} .\"{{{ bootwait .IP \fBbootwait\fP The process will be executed during system boot, while .B init waits for its termination (e.g.\& /etc/rc). The \fIrunlevels\fP field is ignored. .\"}}} .\"{{{ off .IP \fBoff\fP This does nothing. .\"}}} .\"{{{ ondemand .IP \fBondemand\fP A process marked with an \fBondemand\fP runlevel will be executed whenever the specified \fBondemand\fP runlevel is called. However, no runlevel change will occur (\fBondemand\fP runlevels are `a', `b', and `c'). .\"}}} .\"{{{ initdefault .IP \fBinitdefault\fP An \fBinitdefault\fP entry specifies the runlevel which should be entered after system boot. If none exists, .B init will ask for a runlevel on the console. The \fIprocess\fP field is ignored. .\"}}} .\"{{{ sysinit .IP \fBsysinit\fP The process will be executed during system boot. It will be executed before any \fBboot\fP or \fB bootwait\fP entries. The \fIrunlevels\fP field is ignored. .\"}}} .\"{{{ powerwait .IP \fBpowerwait\fP The process will be executed when the power goes down. \fBinit\fR is usually informed about this by a process talking to a UPS connected to the computer. \fBinit\fP will wait for the process to finish before continuing. .\"}}} .\"{{{ powerfail .IP \fBpowerfail\fP As for \fBpowerwait\fP, except that \fBinit\fP does not wait for the process's completion. .\"}}} .\"{{{ powerokwait .IP \fBpowerokwait\fP This process will be executed as soon as \fBinit\fP is informed that the power has been restored. .\"}}} .\"{{{ powerfailnow .IP \fBpowerfailnow\fP This process will be executed when \fBinit\fP is told that the battery of the external UPS is almost empty and the power is failing (provided that the external UPS and the monitoring process are able to detect this condition). .\"}}} .\"{{{ ctrlaltdel .IP \fBctrlaltdel\fP The process will be executed when \fBinit\fP receives the \fBSIGINT\fP signal. This means that someone on the system console has pressed the \fBCTRL\-ALT\-DEL\fP key combination. Typically one wants to execute some sort of \fBshutdown\fP either to get into single\-user level or to reboot the machine. .\"}}} .\"{{{ kbrequest .IP \fBkbrequest\fP The process will be executed when \fBinit\fP receives a signal from the keyboard handler that a special key combination was pressed on the console keyboard. .sp The documentation for this function is not complete yet; more documentation can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time of this writing). Basically you want to map some keyboard combination to the "KeyboardSignal" action. For example, to map Alt-Uparrow for this purpose use the following in your keymaps file: .RS .sp alt keycode 103 = KeyboardSignal .sp .RE .\"}}} .\"}}} .\"{{{ Examples .SH EXAMPLES This is an example of a inittab which resembles the old Linux inittab: .RS .sp .nf .ne 7 # inittab for linux id:1:initdefault: rc::bootwait:/etc/rc 1:1:respawn:/etc/getty 9600 tty1 2:1:respawn:/etc/getty 9600 tty2 3:1:respawn:/etc/getty 9600 tty3 4:1:respawn:/etc/getty 9600 tty4 .fi .sp .RE This inittab file executes \fI/etc/rc\fP during boot and starts gettys on tty1\-tty4. .PP A more elaborate \fBinittab\fP with different runlevels (see the comments inside): .RS .sp .nf .ne 19 # Level to run in id:2:initdefault: # Boot-time system configuration/initialization script. si::sysinit:/etc/init.d/rcS # What to do in single-user mode. ~:S:wait:/sbin/sulogin # /etc/init.d executes the S and K scripts upon change # of runlevel. # # Runlevel 0 is halt. # Runlevel 1 is single-user. # Runlevels 2-5 are multi-user. # Runlevel 6 is reboot. l0:0:wait:/etc/init.d/rc 0 l1:1:wait:/etc/init.d/rc 1 l2:2:wait:/etc/init.d/rc 2 l3:3:wait:/etc/init.d/rc 3 l4:4:wait:/etc/init.d/rc 4 l5:5:wait:/etc/init.d/rc 5 l6:6:wait:/etc/init.d/rc 6 # What to do at the "3 finger salute". ca::ctrlaltdel:/sbin/shutdown -t1 -h now # Runlevel 2,3: getty on virtual consoles # Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1) 1:23:respawn:/sbin/getty tty1 VC linux 2:23:respawn:/sbin/getty tty2 VC linux 3:23:respawn:/sbin/getty tty3 VC linux 4:23:respawn:/sbin/getty tty4 VC linux S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320 S1:3:respawn:/sbin/mgetty -x0 -D ttyS1 .fi .sp .RE .\"}}} .\"{{{ Files .SH FILES /etc/inittab .\"}}} .\"{{{ Author .SH AUTHOR \fBinit\fP was written by .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME . This manual page was written by .MT lederer@\:francium\:.informatik\:.uni-bonn\:.de Sebastian Lederer .ME and modified by .MT u31b3hs@\:pool\:.informatik\:.rwth-aachen\:.de Michael Haardt .ME . .\"}}} .\"{{{ See also .SH "SEE ALSO" .BR init (8), .BR telinit (8) .\"}}} sysvinit-3.14/man/killall5.8000066400000000000000000000036061475234444100157230ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2003 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .TH KILLALL5 8 "04 Nov 2003" "sysvinit " "Linux System Administrator's Manual" .SH NAME killall5 - send a signal to all processes .SH SYNOPSIS .B killall5 .B \-signalnumber .RB [ \-o .IR omitpid [, omitpid ...]] .RB [ \-o .IR omitpid [, omitpid ...]...] .SH DESCRIPTION .B killall5 is the SystemV \fBkillall\fR command. It sends a signal to all processes except kernel threads and the processes in its own session, so it won't kill the shell that is running the script it was called from. Its primary (only) use is in the \fBrc\fP scripts found in the \fI/etc/init.d\fP directory. .SH OPTIONS .IP "\fB-o\fP \fIomitpid\fP" Tells \fBkillall5\fP to omit processes with that process id. .SH NOTES \fBkillall5\fP can also be invoked as \fBpidof\fP(8), which is simply a (symbolic) link to the \fBkillall5\fP program. .SH EXIT STATUS The program return zero if it killed processes. It returns 2 if no process were killed, and 1 if it was unable to find any processes (\fI/proc/\fP is missing). .SH SEE ALSO .BR halt (8), .BR reboot (8), .BR pidof (8) .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME sysvinit-3.14/man/last.1000066400000000000000000000104541475234444100151450ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2004 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .\"{{{}}} .\"{{{ Title .TH LAST, LASTB 1 "Jul 31, 2004" "sysvinit " "User Commands" .\"}}} .\"{{{ Name .SH NAME last, lastb \- show listing of last logged in users .\"}}} .\"{{{ Synopsis .SH SYNOPSIS .B last .RB [ \-R ] .RB [ \-\fInum\fP ] [\-\fBn\fP \fInum\/\fP] .RB [ \-adFiowx ] [\-\fBf\fP \fIfile\/\fP] [\-\fBt\fP \fIYYYYMMDDHHMMSS\/\fP] .RI [ name... ] .RI [ tty... ] .br .B lastb .RB [ \-R ] .RB [ \-\fInum\fP ] [\-\fBn\fP \fInum\/\fP] [\-\fBf\fP \fIfile\/\fP] .RB [ \-adFiowx ] .RI [ name... ] .RI [ tty... ] .\"}}} .\"{{{ Description .SH DESCRIPTION .B Last searches back through the file \fB/var/log/wtmp\fP (or the file designated by the \fB\-f\fP flag) and displays a list of all users logged in (and out) since that file was created. Names of users and tty's can be given, in which case \fBlast\fP will show only those entries matching the arguments. Names of ttys can be abbreviated, thus \fBlast 0\fP is the same as \fBlast tty0\fP. .PP When \fBlast\fP catches a \fBSIGINT\fP signal (generated by the interrupt key, usually control-C) or a \fBSIGQUIT\fP signal (generated by the quit key, usually control-\e), \fBlast\fP will show how far it has searched through the file; in the case of the \fBSIGINT\fP signal \fBlast\fP will then terminate. .PP The pseudo user \fBreboot\fP logs in each time the system is rebooted. Thus \fBlast reboot\fP will show a log of all reboots since the log file was created. .PP \fBlastb\fP is the same as \fBlast\fP, except that by default it shows a log of the file \fB/var/log/btmp\fP, which contains all the bad login attempts. .\"}}} .\"{{{ Options .SH OPTIONS .IP "\fB\-f\fP \fIfile\fP" Tells \fBlast\fP to use a specific file instead of \fI/var/log/wtmp\fP. .IP \fB\-\fP\fInum\fP This is a count telling \fBlast\fP how many lines to show. .IP "\fB\-n\fP \fInum\fP" The same. .IP "\fB\-t\fP \fIYYYYMMDDHHMMSS\fP" Display the state of logins as of the specified time. This is useful, e.g., to determine easily who was logged in at a particular time -- specify that time with \fB\-t\fP and look for "still logged in". .IP \fB\-R\fP Suppresses the display of the hostname field. .IP \fB\-a\fP Display the hostname in the last column. Useful in combination with the next flag. .IP \fB\-d\fP For non-local logins, Linux stores not only the host name of the remote host but its IP number as well. This option translates the IP number back into a hostname. .IP \fB\-F\fP Print full login and logout times and dates. .IP \fB\-i\fP This option is like \fB-d\fP in that it displays the IP number of the remote host, but it displays the IP number in numbers-and-dots notation. .IP \fB\-l\fP This option allows the display of usernames longer than 8 characters. This may mess up formatting in some programs and make the output wider than the standard 80 characters. .IP \fB\-o\fP Read an old-type wtmp file (written by linux-libc5 applications). .IP \fB\-w\fP Display full user and domain names in the output. .IP \fB\-x\fP Display the system shutdown entries and run level changes. .\"}}} .SH NOTES The files \fIwtmp\fP and \fIbtmp\fP might not be found. The system only logs information in these files if they are present. This is a local configuration issue. If you want the files to be used, they can be created with a simple \fBtouch\fP(1) command (for example, \fBtouch /var/log/wtmp\fP). .\"{{{ Files .SH FILES /var/log/wtmp .br /var/log/btmp .\"}}} .\"{{{ Author .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME .\"}}} .\"{{{ See also .SH "SEE ALSO" .BR shutdown (8), .BR login (1), .BR init (8) .\"}}} sysvinit-3.14/man/lastb.1000066400000000000000000000000201475234444100152730ustar00rootroot00000000000000.so man1/last.1 sysvinit-3.14/man/logsave.8000066400000000000000000000031261475234444100156470ustar00rootroot00000000000000.\" -*- nroff -*- .\" Copyright 2003 by Theodore Ts'o. All Rights Reserved. .\" This file may be copied under the terms of the GNU Public License. .\" .TH LOGSAVE 8 "" "sysvinit " "Linux System Administrator's Manual" .SH NAME logsave \- save the output of a command in a logfile .SH SYNOPSIS .B logsave [ .B \-asv ] .I logfile cmd_prog [ ... ] .SH DESCRIPTION The .B logsave program will execute .I cmd_prog with the specified argument(s), and save a copy of its output to .IR logfile . If the containing directory for .I logfile does not exist, .B logsave will accumulate the output in memory until it can be written out. A copy of the output will also be written to standard output. .PP If .I cmd_prog is a single hyphen ('-'), then instead of executing a program, .B logsave will take its input from standard input and save it in .IR logfile . .PP .B logsave is useful for saving the output of initial boot scripts until the \fI/var\fP partition is mounted, so the output can be written to \fI/var/log\fP. .SH OPTIONS .TP .B \-a This option will cause the output to be appended to .IR logfile , instead of replacing its current contents. .TP .B \-s This option will cause .B logsave to skip writing to the log file text which is bracketed with a control-A (ASCII 001 or Start of Header) and control-B (ASCII 002 or Start of Text). This allows progress bar information to be visible to the user on the console, while not being written to the log file. .TP .B \-v This option will make .B logsave to be more verbose in its output to the user. .SH AUTHOR .MT tytso@mit\:.edu Theodore Ts'o .ME .SH SEE ALSO .BR fsck (8) sysvinit-3.14/man/mesg.1000066400000000000000000000035301475234444100151320ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2001 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .\"{{{}}} .\"{{{ Title .TH MESG 1 "Feb 26, 2001" "sysvinit " "User Commands" .\"}}} .\"{{{ Name .SH NAME mesg \- control write access to your terminal .\"}}} .\"{{{ Synopsis .SH SYNOPSIS .B mesg .RB [ y | n ] .\"}}} .\"{{{ Description .SH DESCRIPTION .B mesg controls the access to your terminal by others. It's typically used to allow or disallow other users to write to your terminal (see \fBwrite\fP(1)). .\"}}} .\"{{{ Options .SH OPTIONS .IP \fBy\fP Allow write access to your terminal. .IP \fBn\fP Disallow write access to your terminal. .PP If no option is given, \fBmesg\fP prints out the current access state of your terminal. .\"}}} .\"{{{ Notes .SH NOTES \fBmesg\fP assumes that its standard input is connected to your terminal. That also means that if you are logged in multiple times, you can get/set the mesg status of other sessions by using redirection. For example "mesg n < /dev/pts/46". .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME .\"}}} .\"{{{ See also .SH "SEE ALSO" .BR talk (1), .BR write (1), .BR wall (1) .\"}}} sysvinit-3.14/man/mountpoint.1000066400000000000000000000054651475234444100164240ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998-2004 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .TH MOUNTPOINT 1 "Mar 15, 2004" "sysvinit " "User Commands" .SH NAME mountpoint \- see if a directory is a mountpoint .SH SYNOPSIS .B mountpoint .RB [ \-q ] .RB [ \-d ] .I /path/to/directory .br .B mountpoint .B \-x .I /dev/device .SH DESCRIPTION \fBmountpoint\fP checks if the directory is a mountpoint. .SH OPTIONS .IP \fB\-q\fP Be quiet - don't print anything. .IP \fB\-d\fP Print major/minor device number of the filesystem on stdout. .IP \fB\-p\fP Check Linux's \fI/proc/mounts\fP file to try to detect circular mount points. .IP \fB\-x\fP Print major/minor device number of the blockdevice on stdout. .SH EXIT STATUS Zero if the directory is a mountpoint, non-zero if not. .SH NOTES Symbolic links are not followed, except when the \fB-x\fP option is used. To force following symlinks, add a trailing slash to the path of the directory. .PP The name of the command is misleading when the \fB-x\fP option is used, but the option is useful for comparing if a directory and a device match up, and there is no other command that can print the info easily. .PP The mountpoint command fails when a directory is binded to one of its grandparents. For example, if /a/b/c/d is a mount point for /a/b then mountpoint will report /a/b/c/d is not a valid mount point. This is because both the original directory and its new mount point share the same inode and device number. .PP The circular mount problem can be worked around on Linux systems by using the\fB-p\fP flag to check the \fI/proc/mounts\fP file for references to the circular mount bind. When using the \fB-p\fP flag, make sure to specify the full path (ie \fI/home/user/mp\fP and not just \fImp\fP). Also, \fBmountpoint\fP may still fail if there are spaces in the mount point's path, even when using the \fB-p\fP flag because of the way \fB/proc/mounts\fP mangles the spaces in the path name. Of course, if the admin is using circular mount points with spaces in the name, there are bigger concerns. .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME .SH "SEE ALSO" .BR stat (1) sysvinit-3.14/man/pidof.8000066400000000000000000000104111475234444100153030ustar00rootroot00000000000000'\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998 Miquel van Smoorenburg. .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, write to the Free Software .\" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA .\" .TH PIDOF 8 "01 Sep 1998" "sysvinit " "Linux System Administrator's Manual" .SH NAME pidof \- find the process ID of a running program .SH SYNOPSIS .B pidof .RB [ \-s ] .RB [ \-c ] .RB [ \-n ] .RB [ \-x ] .RB [ \-z ] .RB [ \-o .IR omitpid [ \fB,\fPomitpid "...\&]]" .RB [ \-o .IR omitpid [ \fB,\fPomitpid ...]...\&] .RB [ \-d .IR sep ] .I program .RI [ program "...]" .SH DESCRIPTION .B pidof finds the process id's (PIDs) of the named programs. It prints those id's on the standard output. This program is on some systems used in run-level change scripts, especially when the system has a \fISystem-V\fP like \fIrc\fP structure. In that case these scripts are located in \fI/etc/rc?.d\fP, where ? is the runlevel. If the system has a \fBstart-stop-daemon\fP(8) program that should be used instead. .SH OPTIONS .IP \fB\-s\fP Single shot - this instructs the program to only return one \fIpid\fP. .IP \fB\-c\fP Only return process PIDs that are running with the same root directory. This option is ignored for non-root users, as they will be unable to check the current root directory of processes they do not own. .IP \fB\-n\fP Avoid .BR stat (2) system function call on all binaries which are located on network based file systems like .BR NFS . Instead of using this option the variable .B PIDOF_NETFS may be set and exported. .IP \fB\-q\fP Do not display matched PIDs to standard out. Simply exit with a status of true or false to indicate whether a matching PID was found. .IP \fB\-x\fP Scripts too - this causes the program to also return process id's of shells running the named scripts. .IP \fB\-z\fP Try to detect processes which are stuck in zombie (Z) status. Usually these processes are skipped as trying to deal with them can cause pidof or related tools to hang. Note: In the past pidof would ignore processes in the uninterruptable state (D), unless the \fB\-z\fP flag was specified. This is no longer the case. The \fBpidof\fP program will find and report processes in the D state whether \fB\-z\fP is specified or not. .IP "\-d \fIsep\fP" Tells \fIpidof\fP to use \fIsep\fP as an output separator if more than one PID is shown. The default separator is a space. .IP "\-o \fIomitpid\fP" Tells \fIpidof\fP to omit processes with that process id. The special pid \fB%PPID\fP can be used to name the parent process of the \fBpidof\fP program, in other words the calling shell or shell script. .SH "EXIT STATUS" .TP .B 0 At least one program was found with the requested name. .TP .B 1 No program was found with the requested name. .SH NOTES \fIpidof\fP is actually the same program as \fBkillall5\fP(8); the program behaves according to the name under which it is called. .PP When \fBpidof\fP is invoked with a full pathname to the program it should find the pid of, it is reasonably safe. Otherwise it is possible that it returns PIDs of running programs that happen to have the same name as the program you're after but are actually other programs. Note that the executable name of running processes is calculated with .BR readlink (2), so symbolic links to executables will also match. .PP Zombie processes or processes in disk sleep (states Z and D, respectively) are ignored, as attempts to access the stats of these will sometimes fail. The \fB\-z\fP flag (see above) tells \fBpidof\fP to try to detect these sleeping and zombie processes, at the risk of failing or hanging. .SH SEE ALSO .BR shutdown (8), .BR init (8), .BR halt (8), .BR reboot (8), .BR killall5 (8) .SH AUTHOR .MT miquels@\:cistron\:.nl Miquel van Smoorenburg .ME sysvinit-3.14/man/po/000077500000000000000000000000001475234444100145325ustar00rootroot00000000000000sysvinit-3.14/man/po/de.po000066400000000000000000006041311475234444100154670ustar00rootroot00000000000000# German translation of the sysvinit man pages. # Martin Okrslar , 2000. # Martin Schulze , 2001. # Martin Eberhard Schauer , 2010. # Chris Leick , 2010. # Helge Kreutzmann , 2016, 2018-2021. # Mario Blättermann , 2014, 2018-2021. msgid "" msgstr "" "Project-Id-Version: sysvinit-man\n" "POT-Creation-Date: 2021-12-27 14:19+0100\n" "PO-Revision-Date: 2021-12-27 22:14+0100\n" "Last-Translator: Mario Blättermann \n" "Language-Team: German \n" "Language: de\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Generator: Lokalize 21.12.0\n" #. type: TH #: ../bootlogd.8:18 #, no-wrap msgid "BOOTLOGD" msgstr "BOOTLOGD" #. type: TH #: ../bootlogd.8:18 #, no-wrap msgid "Jul 21, 2003" msgstr "21. Juli 2003" #. type: TH #: ../bootlogd.8:18 ../fstab-decode.8:20 ../halt.8:20 ../init.8:20 #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 ../killall5.8:18 #: ../last.1:20 ../logsave.8:5 ../mesg.1:20 ../mountpoint.1:18 ../pidof.8:18 #: ../readbootlog.1:20 ../runlevel.8:18 ../shutdown.8:20 ../sulogin.8:18 #: ../utmpdump.1:18 ../wall.1:18 #, no-wrap msgid "sysvinit @VERSION@" msgstr "sysvinit @VERSION@" #. type: TH #: ../bootlogd.8:18 ../fstab-decode.8:20 ../halt.8:20 ../init.8:20 #: ../killall5.8:18 ../logsave.8:5 ../pidof.8:18 ../runlevel.8:18 #: ../shutdown.8:20 ../sulogin.8:18 #, no-wrap msgid "Linux System Administrator's Manual" msgstr "Linux-Systemverwaltungshandbuch" #. type: SH #: ../bootlogd.8:19 ../fstab-decode.8:22 ../halt.8:23 ../init.8:23 #: ../initctl.5:18 ../initscript.5:19 ../inittab.5:23 ../killall5.8:19 #: ../last.1:23 ../logsave.8:6 ../mesg.1:23 ../mountpoint.1:19 ../pidof.8:19 #: ../readbootlog.1:23 ../runlevel.8:19 ../shutdown.8:23 ../sulogin.8:19 #: ../utmpdump.1:19 ../wall.1:20 #, no-wrap msgid "NAME" msgstr "BEZEICHNUNG" #. type: Plain text #: ../bootlogd.8:21 msgid "bootlogd - record boot messages" msgstr "bootlogd - Boot-Meldungen aufzeichnen" #. type: SH #: ../bootlogd.8:21 ../fstab-decode.8:25 ../halt.8:27 ../init.8:27 #: ../initctl.5:20 ../initscript.5:21 ../killall5.8:21 ../last.1:27 #: ../logsave.8:8 ../mesg.1:27 ../mountpoint.1:21 ../pidof.8:21 #: ../readbootlog.1:27 ../runlevel.8:21 ../shutdown.8:27 ../sulogin.8:21 #: ../utmpdump.1:21 ../wall.1:23 #, no-wrap msgid "SYNOPSIS" msgstr "ÜBERSICHT" #. type: Plain text #: ../bootlogd.8:31 msgid "" "B [B<-c>] [B<-d>] [B<-e>] [B<-r>] [B<-s>] [B<-v>] [I< >B<-" "l>I< logfile >] [I< >B<-p>I< pidfile >]" msgstr "" "B [B<-c>] [B<-d>] [B<-e>] [B<-r>] [B<-s>] [B<-v>] [I< >B<-" "l>I< Protokolldatei >] [I< >B<-p>I< PID-Datei >]" #. type: SH #: ../bootlogd.8:31 ../fstab-decode.8:28 ../halt.8:53 ../init.8:46 #: ../initctl.5:22 ../initscript.5:23 ../inittab.5:28 ../killall5.8:28 #: ../last.1:48 ../logsave.8:14 ../mesg.1:32 ../mountpoint.1:30 ../pidof.8:36 #: ../readbootlog.1:34 ../runlevel.8:24 ../shutdown.8:36 ../sulogin.8:27 #: ../utmpdump.1:25 ../wall.1:28 #, no-wrap msgid "DESCRIPTION" msgstr "BESCHREIBUNG" #. type: Plain text #: ../bootlogd.8:35 msgid "" "B runs in the background and copies all strings sent to the I device to a logfile. If the I is not accessible, the " "messages will be kept in memory until it is." msgstr "" "B wird im Hintergrund ausgeführt und kopiert alle an das Gerät I gesendeten Zeichenketten in eine Protokolldatei. Falls auf die " "I nicht zugegriffen werden kann, werden die Meldungen im " "Speicher behalten, bis der Zugriff wieder möglich ist." #. type: SH #: ../bootlogd.8:35 ../halt.8:68 ../killall5.8:34 ../last.1:70 ../logsave.8:39 #: ../mesg.1:38 ../mountpoint.1:33 ../pidof.8:44 ../readbootlog.1:42 #: ../runlevel.8:49 ../shutdown.8:54 ../utmpdump.1:28 ../wall.1:52 #, no-wrap msgid "OPTIONS" msgstr "OPTIONEN" #. type: IP #: ../bootlogd.8:36 ../halt.8:75 ../last.1:87 ../mountpoint.1:36 #, no-wrap msgid "B<-d>" msgstr "B<-d>" #. type: Plain text #: ../bootlogd.8:38 msgid "Do not fork and run in the background." msgstr "" #. type: IP #: ../bootlogd.8:38 #, no-wrap msgid "B<-e>" msgstr "B<-e>" #. type: Plain text #: ../bootlogd.8:42 msgid "" "Print escape characters to the boot log file. This turns off filtering of " "escape characters and allows tools like GNU B(1) to see and use colour " "control characters (show the log in colour)." msgstr "" "gibt Escape-Zeichen in die Boot-Protokolldatei aus. Dadurch wird die " "Filterung der Escape-Zeichen deaktiviert und Werkzeugen wie GNU B(1) " "ermöglicht, diese zu sehen und Farb-Steuerzeichen zu verwenden (also das " "Protokoll farbig anzuzeigen)." #. type: IP #: ../bootlogd.8:42 ../pidof.8:47 ../shutdown.8:101 #, no-wrap msgid "B<-c>" msgstr "B<-c>" #. type: Plain text #: ../bootlogd.8:47 msgid "" "Attempt to write to the logfile even if it does not yet exist. Without this " "option, B will wait for the logfile to appear before attempting to " "write to it. This behavior prevents B from creating logfiles under " "mount points." msgstr "" "versucht, auch dann in die Protokolldatei zu schreiben, wenn diese noch " "nicht existiert. Ohne diese Option wartet B, bis die " "Protokolldatei erscheint, bevor ein Schreibversuch unternommen wird. Dieses " "Verhalten hindert B daran, Protokolldateien unterhalb von " "Einhängepunkten zu erstellen." #. type: IP #: ../bootlogd.8:47 ../shutdown.8:64 ../utmpdump.1:31 #, no-wrap msgid "B<-r>" msgstr "B<-r>" #. type: Plain text #: ../bootlogd.8:50 msgid "" "If there is an existing logfile called I rename it to I " "unless I already exists." msgstr "" "Eine vorhandene I wird umbenannt, indem dem Namen eine Tilde " "angehängt wird (I), außer wenn die I " "bereits vorhanden ist." #. type: IP #: ../bootlogd.8:50 ../logsave.8:45 ../pidof.8:45 #, no-wrap msgid "B<-s>" msgstr "B<-s>" #. type: Plain text #: ../bootlogd.8:56 msgid "" "Ensure that the data is written to the file after each line by calling " "B(3). This will slow down a B(8) process running in " "parallel." msgstr "" "stellt sicher, dass die Daten tatsächlich in die Datei geschrieben werden, " "indem nach jeder Zeile B(3) aufgerufen wird. Dadurch wird ein " "parallel laufender B(8)-Prozess verlangsamt." #. type: TP #: ../bootlogd.8:56 ../logsave.8:53 #, no-wrap msgid "B<-v>" msgstr "B<-v>" #. type: Plain text #: ../bootlogd.8:58 msgid "Show version." msgstr "zeigt die Version an." #. type: IP #: ../bootlogd.8:58 #, no-wrap msgid "B<-l> I" msgstr "B<-l> I" #. type: Plain text #: ../bootlogd.8:60 msgid "Log to this logfile. The default is I." msgstr "" "speichert in die angegebene Protokolldatei. Die Vorgabe ist I." #. type: IP #: ../bootlogd.8:60 #, no-wrap msgid "B<-p> I" msgstr "B<-p> I" #. type: Plain text #: ../bootlogd.8:62 msgid "Put process-id in this file. The default is no pidfile." msgstr "" "speichert die Prozesskennung (PID) in dieser Datei. Standardmäßig wird keine " "PID-Datei gespeichert." #. }}} #. type: SH #: ../bootlogd.8:62 ../halt.8:94 ../initctl.5:119 ../initscript.5:60 #: ../killall5.8:37 ../last.1:107 ../mesg.1:48 ../mountpoint.1:44 ../pidof.8:87 #: ../shutdown.8:216 #, no-wrap msgid "NOTES" msgstr "ANMERKUNGEN" #. type: Plain text #: ../bootlogd.8:67 msgid "" "B saves log data which includes control characters. The log is " "technically a text file, but not very easy for humans to read. To address " "this the B(1) command can be used to display the boot log " "without the control characters." msgstr "" #. type: SH #: ../bootlogd.8:67 ../utmpdump.1:52 #, no-wrap msgid "BUGS" msgstr "FEHLER" #. type: Plain text #: ../bootlogd.8:77 msgid "" "B works by redirecting the console output from the console " "device. (Consequently B requires PTY support in the kernel " "configuration.) It copies that output to the real console device and to a " "log file. There is no standard way of ascertaining the real console device " "if you have a new-style I device (major 5, minor 1) so " "B parses the kernel command line looking for B lines " "and deduces the real console device from that. If that syntax is ever " "changed by the kernel, or a console type is used that B does not " "know about then B will not work." msgstr "" #. type: SH #: ../bootlogd.8:78 ../halt.8:116 ../init.8:337 ../initctl.5:147 #: ../initscript.5:68 ../inittab.5:255 ../killall5.8:48 ../last.1:120 #: ../logsave.8:58 ../mesg.1:53 ../mountpoint.1:66 ../pidof.8:110 #: ../readbootlog.1:52 ../runlevel.8:57 ../shutdown.8:232 ../sulogin.8:84 #: ../utmpdump.1:60 ../wall.1:74 #, no-wrap msgid "AUTHOR" msgstr "AUTOR" #. type: Plain text #: ../bootlogd.8:82 ../halt.8:122 ../initscript.5:72 ../killall5.8:51 #: ../last.1:126 ../mesg.1:59 ../mountpoint.1:70 ../pidof.8:113 #: ../runlevel.8:60 ../shutdown.8:238 ../sulogin.8:88 ../wall.1:77 msgid "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>" msgstr "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>" #. type: SH #: ../bootlogd.8:82 ../fstab-decode.8:67 ../halt.8:122 ../init.8:346 #: ../initctl.5:151 ../initscript.5:72 ../inittab.5:270 ../killall5.8:44 #: ../last.1:126 ../logsave.8:62 ../mesg.1:59 ../mountpoint.1:70 ../pidof.8:104 #: ../readbootlog.1:58 ../runlevel.8:54 ../shutdown.8:238 ../sulogin.8:88 #: ../utmpdump.1:62 ../wall.1:70 #, no-wrap msgid "SEE ALSO" msgstr "SIEHE AUCH" #. type: Plain text #: ../bootlogd.8:85 msgid "B(8), B(3), B(1)" msgstr "B(8), B(3), B(1)" #. type: TH #: ../fstab-decode.8:20 #, no-wrap msgid "FSTAB-DECODE" msgstr "FSTAB-DECODE" #. type: TH #: ../fstab-decode.8:20 #, no-wrap msgid "May 2006" msgstr "Mai 2006" #. type: Plain text #: ../fstab-decode.8:24 msgid "fstab-decode - run a command with fstab-encoded arguments" msgstr "fstab-decode - einen Befehl mit fstab-kodierten Argumenten ausführen" #. type: Plain text #: ../fstab-decode.8:27 msgid "B I [I]..." msgstr "B I [I] …" #. type: Plain text #: ../fstab-decode.8:34 msgid "" "B decodes escapes (such as newline characters and other " "whitespace) in the specified Is and uses them to run I. " "The argument escaping uses the same rules as path escaping in I, " "I and I." msgstr "" #. type: Plain text #: ../fstab-decode.8:38 msgid "" "In essence B can be used anytime we want to pass multiple " "parameters to a command as a list of command line arguments. It turns output " "like this:" msgstr "" #. type: Plain text #: ../fstab-decode.8:43 #, no-wrap msgid "" "/root\n" "/mnt/remote-disk\n" "/home\n" msgstr "" #. type: Plain text #: ../fstab-decode.8:49 #, no-wrap msgid "" "Into one long list of parameters, \"/root /mnt/remote-disk /home\". This\n" "can be useful when trying to work with multiple filesystems at once. For\n" "instance, we can use it to unmount multiple NFS shares. This program also\n" "removes whitespace and other characters which might cause programs such\n" "as B(8) or B(8) to fail.\n" msgstr "" #. type: SH #: ../fstab-decode.8:50 ../killall5.8:40 ../mountpoint.1:42 ../pidof.8:80 #, no-wrap msgid "EXIT STATUS" msgstr "EXIT-STATUS" #. type: Plain text #: ../fstab-decode.8:56 msgid "" "B exits with status 127 if I can't be run. Otherwise " "it exits with the status returned by I." msgstr "" "B beendet sich mit dem Status 127, falls der I nicht " "ausgeführt werden kann. Anderenfalls beendet es sich mit dem vom I " "zurückgegebenen Status." #. }}} #. }}} #. {{{ Examples #. type: SH #: ../fstab-decode.8:57 ../initctl.5:93 ../initscript.5:28 ../inittab.5:184 #, no-wrap msgid "EXAMPLES" msgstr "BEISPIELE" #. type: Plain text #: ../fstab-decode.8:62 msgid "" "The following example reads I, finds all instances of VFAT " "filesystems and prints their mount points (argument 2 in the I " "file). B then runs the specified program, B(8), and " "passes it the list of VFAT mountpoints. This unmounts all VFAT partitions." msgstr "" "Das folgende Beispiel liest die Datei I, findet alle Vorkommen von " "VFAT-Dateisystemen und gibt deren Einhängepunkte aus (das 2. Argument in der " "I-Datei). B führt dann das angegebene Programm aus " "(B(8)) und übergibt an dieses eine Liste der VFAT-Einhängepunkte. " "Dadurch werden alle VFAT-Partitionen ausgehängt." #. type: Plain text #: ../fstab-decode.8:65 #, no-wrap msgid "B\n" msgstr "B\n" #. type: Plain text #: ../fstab-decode.8:68 msgid "B(5)" msgstr "B(5)" #. type: TH #: ../halt.8:20 #, no-wrap msgid "HALT" msgstr "HALT" #. type: TH #: ../halt.8:20 #, no-wrap msgid "Nov 6, 2001" msgstr "6. November 2001" #. }}} #. {{{ Synopsis #. type: Plain text #: ../halt.8:27 msgid "halt, reboot, poweroff - stop the system" msgstr "halt, poweroff, reboot - das System anhalten" #. type: Plain text #: ../halt.8:36 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-p>] [B<-h>]" msgstr "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-p>] [B<-h>]" #. type: Plain text #: ../halt.8:43 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>]" msgstr "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>]" #. }}} #. {{{ Description #. type: Plain text #: ../halt.8:53 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-h>]" msgstr "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-h>]" #. type: Plain text #: ../halt.8:57 msgid "" "B notes that the system is being brought down in the file I, and then either tells the kernel to halt, reboot or power-off the " "system." msgstr "" #. type: Plain text #: ../halt.8:63 msgid "" "If B or B is called when the system is I in runlevel B<0> " "or B<6>, in other words when it's running normally, B will be " "invoked instead (with the B<-h> or B<-r> flag). For more info see the " "B(8) manpage." msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../halt.8:68 msgid "" "The rest of this manpage describes the behavior in runlevels 0 and 6, that " "is when the systems shutdown scripts are being run." msgstr "" "Der Rest dieser Handbuchseite beschreibt das Verhalten in den Runlevels 0 " "und 6, also wenn die Herunterfahr-Skripte des Systems laufen." #. type: IP #: ../halt.8:69 ../pidof.8:51 ../shutdown.8:95 ../wall.1:53 #, no-wrap msgid "B<-n>" msgstr "B<-n>" #. type: Plain text #: ../halt.8:72 msgid "" "Don't sync before reboot or halt. Note that the kernel and storage drivers " "may still sync. This implies B<-d>." msgstr "" #. type: IP #: ../halt.8:72 ../last.1:102 #, no-wrap msgid "B<-w>" msgstr "B<-w>" #. type: Plain text #: ../halt.8:75 msgid "" "Don't actually reboot or halt but only write the wtmp record (in the I file)." msgstr "" "führt keinen Systemhalt oder Neustart tatsächlich aus, sondern schreibt nur " "den Wtmp-Herunterfahreintrag (in die Datei I)." #. type: Plain text #: ../halt.8:77 msgid "Don't write the wtmp record." msgstr "schreibt keinen Wtmp-Herunterfahreintrag." #. type: IP #: ../halt.8:77 ../shutdown.8:87 ../utmpdump.1:29 #, no-wrap msgid "B<-f>" msgstr "B<-f>" #. type: Plain text #: ../halt.8:79 msgid "Force halt or reboot, don't call B(8)." msgstr "erzwingt Systemhalt oder Neustart und ruft B(8) nicht auf." #. type: IP #: ../halt.8:79 ../last.1:93 #, no-wrap msgid "B<-i>" msgstr "B<-i>" #. type: Plain text #: ../halt.8:83 msgid "" "Shut down all network interfaces just before B or B. Warning: " "This may not work on interfaces which do not have an IP address and should " "ideally be handled by a network manager service." msgstr "" #. type: IP #: ../halt.8:83 ../readbootlog.1:45 ../shutdown.8:68 ../utmpdump.1:35 #, no-wrap msgid "B<-h>" msgstr "B<-h>" #. type: Plain text #: ../halt.8:85 msgid "" "Put all hard drives on the system in stand-by mode just before halt or power-" "off." msgstr "" "versetzt alle Festplattenlaufwerke im System direkt vor Systemhalt oder " "Ausschalten in den Standby-Modus." #. type: IP #: ../halt.8:85 ../mountpoint.1:38 #, no-wrap msgid "B<-p>" msgstr "B<-p>" #. }}} #. {{{ Diagnostics #. type: Plain text #: ../halt.8:90 msgid "" "When halting the system, switch off the power. This is the default when " "B is called as B." msgstr "" "schaltet beim Anhalten des Systems die Energieversorgung ab. Dies ist die " "Vorgabe, wenn B als B aufgerufen wird." #. type: SH #: ../halt.8:90 ../init.8:327 #, no-wrap msgid "DIAGNOSTICS" msgstr "DIAGNOSE" #. }}} #. {{{ Notes #. type: Plain text #: ../halt.8:94 msgid "" "If you're not the superuser, you will get the message `must be superuser'." msgstr "" "Falls Sie nicht der Superuser sind, erhalten Sie die Meldung »must be " "superuser«." #. type: Plain text #: ../halt.8:103 msgid "" "Under older B releases, B and B should never be " "called directly. From release 2.74 on B and B invoke " "B(8) if the system is not in runlevel 0 or 6. This means that if " "B or B cannot find out the current runlevel (for example, when " "I hasn't been initialized correctly and I " "does not exist) B will be called, which might not be what you " "want. Use the B<-f> flag if you want to do a hard B or B." msgstr "" "Unter älteren Versionen von B sollten B und B " "niemals direkt aufgerufen werden. Ab der Version 2.74 rufen B und " "B den Befehl B(8) auf, falls sich das System nicht im " "Runlevel 0 oder 6 befindet. Falls B oder B den aktuellen " "Runlevel nicht ermitteln können (beispielsweise wenn I nicht " "korrekt initialisiert wurde und I nicht existiert), " "bedeutet das, dass B aufgerufen wird, was möglicherweise nicht das " "ist, was Sie wollen. Verwenden Sie den Schalter B<-f>, wenn Sie einen harten " "Systemhalt oder Neustart ausführen wollen." #. type: Plain text #: ../halt.8:109 msgid "" "The B<-h> flag puts all hard disks in standby mode just before halt or power-" "off. Right now this is only implemented for IDE drives. A side effect of " "putting the drive in stand-by mode is that the write cache on the disk is " "flushed. This is important for IDE drives, since the kernel doesn't flush " "the write cache itself before power-off." msgstr "" "Der Schalter B<-h> versetzt alle Festplatten direkt vor dem Systemhalt oder " "Ausschalten in den Standby-Modus. Bislang ist das nur für IDE-Laufwerke " "implemetiert. Ein Nebeneffekt des Versetzens in den Standby-Modus ist, dass " "der Schreib-Cache des Laufwerks geleert wird. Das ist für IDE-Laufwerke " "wichtig, da der Kernel selbst den Schreib-Cache vor dem Ausschalten nicht " "leert." #. type: Plain text #: ../halt.8:113 msgid "" "The B program uses I to find all IDE disk devices, " "which means that I needs to be mounted when B or B is " "called or the B<-h> switch will do nothing." msgstr "" "Das Programm B findet alle IDE-Laufwerke mit Hilfe von I, was bedeutet, dass I beim Aufruf von B oder B " "eingehängt sein muss. Anderenfalls wird der Schalter B<-h> nichts bewirken." #. type: Plain text #: ../halt.8:124 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../init.8:20 #, no-wrap msgid "INIT" msgstr "INIT" #. type: TH #: ../init.8:20 #, no-wrap msgid "29 Jul 2004" msgstr "29. Juli 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../init.8:27 msgid "init, telinit - process control initialization" msgstr "init, telinit - Initialisierung der Prozesssteuerung" #. type: Plain text #: ../init.8:34 msgid "" "B [B< -a >] [B< -s >] [B< -b >] [ B<-z> I ] [B< 0123456Ss >]" msgstr "" "B [B< -a >] [B< -s >] [B< -b >] [ B<-z> I ] [B< 0123456Ss >]" #. type: Plain text #: ../init.8:37 msgid "B [B< --version >]" msgstr "B [B< --version >]" #. type: Plain text #: ../init.8:41 msgid "B [ B<-t> I ] [B< 0123456sSQqabcUu >]" msgstr "B [ B<-t> I ] [B< 0123456sSQqabcUu >]" #. }}} #. {{{ Description #. type: Plain text #: ../init.8:46 msgid "B [ B<-e> I[B<=>I] ]" msgstr "B [ B<-e> I[B<=>I] ]" #. {{{ init #. type: SS #: ../init.8:48 #, no-wrap msgid "Init" msgstr "Init" #. type: Plain text #: ../init.8:55 msgid "" "B is the parent of all processes. Its primary role is to create " "processes from a script stored in the file I (see " "B(5)). This file usually has entries which cause B to spawn " "Bs on each line that users can log in. It also controls autonomous " "processes required by any particular system." msgstr "" "B ist der Elternprozess aller Prozesse. Seine Hauptaufgabe besteht " "darin, Prozesse aus einem Skript in der Datei I zu erzeugen " "(siehe auch B(5)). Diese Datei hat normalerweise Einträge, die " "B dazu veranlassen auf jeder Leitung Bs zu erzeugen, auf der " "sich ein Benutzer einloggen kann. Er steuert auch alle unabhängigen " "Prozesse, die von einem bestimmten System benötigt werden." #. {{{ Runlevels #. type: SH #: ../init.8:57 #, no-wrap msgid "RUNLEVELS" msgstr "RUNLEVEL" #. type: Plain text #: ../init.8:66 msgid "" "A I is a software configuration of the system which allows only a " "selected group of processes to exist. The processes spawned by B for " "each of these runlevels are defined in the I file. B " "can be in one of eight runlevels: B<0\\(en6> and B (a.k.a. B). The " "runlevel is changed by having a privileged user run B, which sends " "appropriate signals to B, telling it which runlevel to change to." msgstr "" "Ein I ist eine Software-Konfiguration des Systems, der es nur " "einer ausgewählten Gruppe von Prozessen erlaubt, ausgeführt zu werden. Die " "Prozesse, die von B für jeden dieser Runlevel erzeugt werden, sind in " "der Datei I definiert. B kann in einem von acht " "Runleveln sein: B<0-6> und B (auch B). B wechselt den Runlevel, " "wenn ein privilegierter Benutzer das Programm B startet, das " "B passende Signale sendet, die ihm mitteilen, in welchen Runlevel es " "wechseln soll." #. type: Plain text #: ../init.8:75 msgid "" "Runlevels B, B<0>, B<1>, and B<6> are reserved. Runlevel S is used to " "initialize the system on boot. When starting runlevel S (on boot) or " "runlevel 1 (switching from a multi-user runlevel) the system is entering " "``single-user mode'', after which the current runlevel is S. Runlevel 0 is " "used to halt the system; runlevel 6 is used to reboot the system." msgstr "" "Die Runlevel B, B<0>, B<1> und B<6> sind reserviert. Der Runlevel S wird " "benutzt, um das System beim Start zu initialisieren. Wenn Runlevel S (beim " "Start) oder Runlevel 1 (umschalten von einem Mehrbenutzer-Runlevel) " "gestartet wird, wechselt das System in den »Einzelbenutzermodus«, nach dem " "der aktuelle Runlevel S ist. Runlevel 0 wird benutzt, um das System zu " "stoppen, Runlevel 6 startet das System neu." #. type: Plain text #: ../init.8:82 msgid "" "After booting through S the system automatically enters one of the multi-" "user runlevels 2 through 5, unless there was some problem that needs to be " "fixed by the administrator in single-user mode. Normally after entering " "single-user mode the administrator performs maintenance and then reboots the " "system." msgstr "" "Nach dem Starten durch S tritt das System automatisch in die Mehrbenutzer-" "Runlevel 2 bis 5 ein, falls es dort kein Problem gibt, das vom Administrator " "im Einzelbenutzermodus behoben werden muss. Normalerweise führt der " "Administrator nach Eintreten in den Einzelbenutzermodus Wartungsarbeiten " "durch und startet dann das System neu." #. type: Plain text #: ../init.8:85 msgid "" "For more information, see the manpages for B(8) and B(5)." msgstr "" "Lesen Sie die Handbuchseiten von B(8) und B(5), um " "weitere Informationen zu erhalten." #. type: Plain text #: ../init.8:88 msgid "" "Runlevels 7-9 are also valid, though not really documented. This is because " "\"traditional\" Unix variants don't use them." msgstr "" "Die Runlevel 7-9 sind ebenfalls gültig, wenngleich nicht wirklich " "dokumentiert. Dies ist deshalb so, weil »traditionelle« Unix-Varianten sie " "nicht benutzen." #. }}} #. type: Plain text #: ../init.8:92 msgid "" "Runlevels I and I are the same. Internally they are aliases for the " "same runlevel." msgstr "" "Die Runlevel I und I sind identisch. Intern sind sie Aliase für den " "gleichen Runlevel." #. type: SH #: ../init.8:93 #, no-wrap msgid "BOOTING" msgstr "SYSTEMSTART" #. type: Plain text #: ../init.8:100 msgid "" "After B is invoked as the last step of the kernel boot sequence, it " "looks for the file I to see if there is an entry of the type " "B (see B(5)). The B entry determines the " "initial runlevel of the system. If there is no such entry (or no I at all), a runlevel must be entered at the system console." msgstr "" "Nachdem B im letzten Schritt des Startprozesses aufgerufen wird, sucht " "es nach der Datei I und sieht nach, ob es dort einen " "B-Eintrag gibt (siehe B(5)). Der Eintrag " "B bestimmt den Anfangs-I des Systems. Falls es dort " "keinen derartigen Eintrag gibt (oder gar keine Datei I " "existiert), muss der I in der Systemkonsole eingegeben werden." #. type: Plain text #: ../init.8:103 msgid "" "Runlevel B or B initialize the system and do not require an I file." msgstr "" "Die Runlevel B oder B initialisieren das System und benötigen keine I-Datei." #. type: Plain text #: ../init.8:105 msgid "In single user mode, B is invoked on I." msgstr "" "Im Einzelbenutzermodus wird B auf I aufgerufen." #. type: Plain text #: ../init.8:109 msgid "" "When entering single user mode, B initializes the consoles B " "settings to sane values. Clocal mode is set. Hardware speed and handshaking " "are not changed." msgstr "" "Beim Eintritt in den Einzelbenutzermodus initialisiert B die B-" "Einstellungen der Konsolen auf vernünftige Werte. Der »Clocal«-Modus wird " "gesetzt. Hardware-Geschwindigkeit und Datenflusssteuerung werden nicht " "geändert." #. type: Plain text #: ../init.8:114 msgid "" "When entering a multi-user mode for the first time, B performs the " "B and B entries to allow file systems to be mounted before " "users can log in. Then all entries matching the runlevel are processed." msgstr "" "Beim ersten Eintritt in den Mehrbenutzermodus führt B die B- und " "B-Einträge aus, um das Einhängen von Dateisystemen zu erlauben, " "bevor Anwender sich anmelden können. Dann werden alle Einträge, die zum " "Runlevel passen, verarbeitet." #. type: Plain text #: ../init.8:118 msgid "" "When starting a new process, B first checks whether the file I exists. If it does, it uses this script to start the process." msgstr "" "Wenn ein neuer Prozess gestartet wird, prüft B zuerst, ob die Datei I existiert. Ist dies der Fall, benutzt es dieses Skript, um " "den Prozess zu starten." #. type: Plain text #: ../init.8:122 msgid "" "Each time a child terminates, B records the fact and the reason it " "died in I and I, provided that these files " "exist." msgstr "" "Jedesmal, wenn ein Kindprozess endet, zeichnet B diesen Umstand und " "den Grund der Beendigung in I und I auf, " "sofern diese Dateien existieren." #. type: SH #: ../init.8:122 #, no-wrap msgid "CHANGING RUNLEVELS" msgstr "RUNLEVEL ÄNDERN" #. type: Plain text #: ../init.8:132 msgid "" "After it has spawned all of the processes specified, B waits for one " "of its descendant processes to die, a powerfail signal, or until it is " "signaled by B to change the system's runlevel. When one of the " "above three conditions occurs, it re-examines the I file. New " "entries can be added to this file at any time. However, B still waits " "for one of the above three conditions to occur. To provide for an " "instantaneous response, the B or B command can wake up B " "to re-examine (reload) the I file." msgstr "" "Nachdem alle vorgesehenen Prozesse erzeugt worden sind, wartet B " "darauf, dass ein untergeordneter Prozess endet, ein Stromausfallsignal oder " "darauf, dass B einen Wechsel des Runlevels signalisiert. Wenn eine " "der drei oben genannten Bedingungen erfüllt ist, untersucht B nochmals " "die I-Datei. Es können jederzeit neue Einträge zu dieser Datei " "hinzugefügt werden. Jedoch wartet B immer noch darauf, dass einer der " "drei oben genannten Bedingungen eintritt. Um eine sofortige Antwort " "bereitzustellen, können die Befehle B oder B B " "aufwecken, um die Datei I erneut zu prüfen (neu zu laden)." # FIXME SIGPWR → B #. type: Plain text #: ../init.8:136 msgid "" "If B is not in single user mode and receives a powerfail signal " "(SIGPWR), it reads the file I. It then starts a command " "based on the contents of this file:" msgstr "" "Falls B sich nicht im Einzelbenutzermodus befindet, und ein " "Stromausfallsignal (SIGPWR) empfängt, liest es die Datei I. Anschließend wird ein Befehl anhand des Inhalts der Datei " "gestartet:" #. type: IP #: ../init.8:136 #, no-wrap msgid "F(AIL)" msgstr "F(EHLSCHLAG)" #. type: Plain text #: ../init.8:139 msgid "" "Power is failing, UPS is providing the power. Execute the B and " "B entries." msgstr "" "Strom fällt aus, die USV versorgt den Rechner mit Strom. Die B- " "und B-Einträge werden ausgeführt." #. type: IP #: ../init.8:139 #, no-wrap msgid "O(K)" msgstr "O(K)" #. type: Plain text #: ../init.8:141 msgid "The power has been restored, execute the B entries." msgstr "" "Stromkreis wurde wieder geschlossen, die B-Einträge werden " "ausgeführt." #. type: IP #: ../init.8:141 #, no-wrap msgid "L(OW)" msgstr "L(OW/niedrig)" #. type: Plain text #: ../init.8:144 msgid "" "The power is failing and the UPS has a low battery. Execute the " "B entries." msgstr "" "Strom fällt aus und der Ladestand der USV ist niedrig. Die B-" "Einträge werden ausgeführt." #. type: Plain text #: ../init.8:148 msgid "" "If I doesn't exist or contains anything else then the " "letters B, B or B, B will behave as if it has read the letter " "B." msgstr "" "Wenn I nicht existiert oder etwas anderes enthält als die " "Buchstaben B, B oder B, wird B sich so verhalten, als hätte " "es den Buchstaben B gelesen." #. type: Plain text #: ../init.8:153 msgid "" "Usage of B and I is discouraged. Someone wanting " "to interact with B should use the I control channel - " "see the B(5) manual page for more documentation about this." msgstr "" "Die Verwendung von B und I werden nicht empfohlen. " "Wenn etwas mit B interagieren möchte, sollte der Steuerkanal I verwendet werden - lesen Sie die Handbuchseite von B(5), " "um weitere Dokumentation darüber zu erhalten." #. }}} #. {{{ telinit #. type: Plain text #: ../init.8:165 msgid "" "When B is requested to change the runlevel, it sends the warning " "signal B to all processes that are undefined in the new runlevel. " "It then waits 3 seconds before forcibly terminating these processes via the " "B signal. Note that B assumes that all these processes (and " "their descendants) remain in the same process group which B originally " "created for them. If any process changes its process group affiliation it " "will not receive these signals. Such processes need to be terminated " "separately." msgstr "" "Falls B die Aufforderung zum Wechsel des Runlevels erhält, sendet es " "das Warnsignal B an alle nicht im neuen Runlevel definierten " "Prozesse. Dann wartet es drei Sekunden bevor es diese Prozesse gewaltsam per " "Signal B beendet. Beachten Sie, dass B davon ausgeht, dass " "diese Prozesse (und ihre Unterprozesse) in der gleichen Prozessgruppe " "verbleiben, die B ursprünglich für sie erstellt hatte. Wenn Prozesse " "ihre Gruppenzugehörigkeit andern, werden Sie diese Signale nicht empfangen. " "Solche Prozesse müssen separat beendet werden." #. type: SH #: ../init.8:165 #, no-wrap msgid "TELINIT" msgstr "TELINIT" #. type: Plain text #: ../init.8:170 msgid "" "B is linked to B. It takes a one-character " "argument and signals B to perform the appropriate action. The " "following arguments serve as directives to B:" msgstr "" "B ist mit B verknüpft. Es empfängt Argumente aus " "einem Buchstaben oder B-Signale, um die zugehörige Aktion " "durchzuführen. Die folgenden Argumente dienen als Anweisungen für B:" #. type: IP #: ../init.8:170 #, no-wrap msgid "B<0>, B<1>, B<2>, B<3>, B<4>, B<5> or B<6>" msgstr "B<0>, B<1>, B<2>, B<3>, B<4>, B<5> oder B<6>" #. type: Plain text #: ../init.8:172 msgid "tell B to switch to the specified run level." msgstr "B mitteilen, in den angegebenen Runlevel zu schalten." #. type: IP #: ../init.8:172 #, no-wrap msgid "B," msgstr "B," # FIXME missing whitespace # FIXME B → I #. type: Plain text #: ../init.8:175 msgid "" "tell B to process only those B file entries having " "runlevel B,B or B." msgstr "" "B mitteilen, nur die Einträge in der Datei B zu " "verarbeiten, die den Runlevel B, B oder B haben." #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "B oder B" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "B mitteilen, die Datei I erneut zu prüfen." #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "B oder B" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "B mitteilen, in den Einzelbenutzermodus zu wechseln." #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "B oder B" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" "B mitteilen, sich selbst erneut (unter Beibehalten des Status) " "auszuführen. Es kommt zu keiner erneuten Ausführung der Datei I. Der Runlevel sollte einer aus B sein, anderenfalls wird " "die Anfrage stillschweigend ignoriert." #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" "B kann dem B-Prozess mitteilen, wie viel Zeit dieser zwischen " "dem Senden der Signale B und B warten soll. Die Vorgabe " "ist drei Sekunden, dies kann aber durch die Option B<-t> geändert werden." #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" "B weist B an, die Umgebung für Prozesse zu ändern, die es " "erzeugt. Das Argument von B<-e> ist entweder in der Form I=I, was " "die Variable I auf den Wert I setzt oder in der FormI (ohne " "Gleichheitszeichen), was die Variable I leert." #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" "B kann nur von Benutzern mit geeigneten Rechten aufgerufen werden." #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" "Das Programm B prüft durch Auswerten der Prozesskennung, ob es B " "oder B ist. Der echte Prozess von B ist immer B<1>. Daraus " "folgt, dass jemand anstelle des Aufrufs B auch nur B als " "Abkürzung benutzen kann." #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "UMGEBUNGSVARIABLEN" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "B setzt folgende Umgebungsvariablen für alle seine Kindprozesse:" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "I" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" "Wie der Name schon sagt. Nützlich, um festzustellen, ob ein Skript direkt " "von B ausgeführt wird." #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "Der aktuelle Runlevel des Systems." #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "Der vorherige Runlevel (nützlich nach einer Änderung des Runlevels)." #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" "Die Systemkonsole. Diese wird tatsächlich vom Kernel vererbt; wenn sie " "jedoch nicht gesetzt ist, wird B sie als Vorgabe auf I " "setzen." #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "BOOTSCHALTER" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" "Es ist möglich, B eine Reihe von Bootschaltern vom Bootmonitor aus (z." "B. LILO oder GRUB) zu übergeben. B akzeptiert folgende Schalter:" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "B<-s, S, single>" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" "Bootet im Einzelbenutzermodus. In diesem Modus wird zuerst die Datei I untersucht und die »rc«-Startskripte werden ausgeführt, bevor die " "Einzelbenutzer-Shell gestartet wird." #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "B<1-5>" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "Runlevel, in den gestartet wird." #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "B<-b>, B" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" "Startet direkt in eine Einzelbenutzer-Shell, ohne irgendwelche anderen " "Startskripte auszuführen." #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "B<-a>, B" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" "Der LILO-Bootloader fügt das Wort »auto« zur Befehlszeile hinzu, wenn der " "Kernel mit der Standard-Befehlszeile (ohne Eingriff des Anwenders) gestartet " "wird. Falls dies gefunden wird, setzt B die Umgebungsvariable " "»AUTOBOOT« auf »yes«. Beachten Sie, dass Sie die nicht für irgendwelche " "Sicherheitsmaßnahmen verwenden können - selbstverständlich kann der Anwender " "»auto« oder B<-a> manuell auf der Befehlszeile angeben." #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "B<-z >I" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" "Das Argument zu B<-z> wird ignoriert. Sie können es benutzen, um die " "Befehlszeile etwas zu verlängern, damit sie etwas mehr Platz auf dem Stack " "reserviert. B kann dann die Befehlszeile derart verändern, dass " "B(1) den aktuellen Runlevel anzeigt." #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" "Wenn dieses Argument alleine verwendet wird, zeigt es die aktuelle Version " "von B auf der Konsole/Standardausgabe an. Dies ist eine schnelle " "Methode, herauszufinden, welche B-Software und Version verwendet wird. " "Nachdem die Versionsinformation angezeigt wurde, beendet sich B sofort " "mit einem Rückgabewert von Null." #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "SCHNITTSTELLE" # FIXME /dev → I #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" "B lauscht auf einem I in /dev, I, auf Nachrichten. " "B benutzt diesen, um mit B zu kommunizieren. Die " "Schnittstelle ist noch nicht sehr ausführlich dokumentiert oder " "fertiggestellt. Wer interessiert ist, sollte die Datei I im " "Unterverzeichnis des B-Quellcode-Tar-Archives studieren." #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "SIGNALE" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "Init reagiert auf mehrere Signale:" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "Hat die gleichen Auswirkungen wie B." #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" "Beim Empfang dieses Signals schließt B seinen Steuerungs-Fifo I und öffnet ihn wieder. Nützlich für Systemstartskripte, wenn I neu eingehängt wird." #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "B" # FIXME shutdown → B(8) #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" "Wenn B B empfängt, schließt B sich und läßt das Steuer-" "FIFO B geschlossen. Damit können Sie sicherstellen, dass " "B keine Dateien offen hält. Allerdings hindert es B auch daran, " "die Runlevel zu ändern. Das bedeutet, dass Befehle wie B(8) nicht " "mehr funktionieren. Der FIFO kann durch Senden des Signals B an " "B wieder geöffnet werden." #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" "Normalerweise sendet der Kernel dieses Signal an I, wenn CTRL-ALT-DEL " "gedrückt wurde. Es aktiviert die Aktion I." #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" "Der Kernel sendet dieses Signal, falls die I-Taste gedrückt " "wurde. Es aktiviert die I-Aktion." #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "KONFORM ZU" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" "B ist kompatibel zu System-V-Init. Es arbeitet eng mit den Skripten in " "den Verzeichnissen I und I zusammen.Falls " "Ihr System diesem Grundsatz folgt, sollte sich in diesem Verzeichnis eine " "B-Datei befinden, die erklärt wie diese Skripte funktionieren." #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:251 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "DATEIEN" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "WARNUNGEN" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" "B geht davon aus, dass alle Prozesse und Kindprozesse in der selben " "Prozessgruppe verbleiben, die ursprünglich für sie eingerichtet wurde. Falls " "einer dieser Prozesse die Gruppe wechselt, kann B ihn nicht mehr " "beenden und es kann passieren, dass Sie in einem Zustand landen, in dem zwei " "Prozesse von einer Terminalzeile Befehle einlesen wollen." #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" "Auf einem Debian-System veranlasst das Eintreten in Runlevel 1, dass alle " "Prozesse mit Ausnahme von Kernel-Threads und dem Skript, das das Beenden " "erledigt und andere Prozesse in deren Sitzung, beendet werden. Als " "Konsequenz davon ist es nicht sicher, von von Runlevel 1 zu einem " "Mehrbenutzer-Runlevel zurückzukehren: Daemons, die in Runlevel S gestartet " "wurden und für normale Operationen benötigt werden, laufen nicht länger. Das " "System sollte neu gestartet werden." #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" "Wenn B herausfindet, dass es kontinuierlich einen Eintrag öfter als " "zehn mal in zwei Minuten neu erzeugt, wird es annehmen, dass ein Fehler in " "der Befehlszeile vorliegt, eine Fehlermeldung auf der Befehlszeile erzeugen " "und sich weigern, den Eintrag auszuführen, bis fünf Minuten vergangen sind " "oder es ein Signal empfängt. Dieses verhindert, dass Systemressourcen " "verschwendet werden, wenn jemandem ein Tippfehler in I " "unterläuft oder das zum Eintrag gehörende Programm gelöscht wird." #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>, ursprüngliche " "Handbuchseite von E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "INITCTL" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "13. April 2018" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "Dateiformate" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "/run/initctl" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" "In der Handbuchseite von B wurde bis vor kurzem noch empfohlen, dass " "Benutzer, die verstehen wollen, wie Meldungen an B gesendet werden, " "doch den Quellcode von I lesen sollten. Dies ist aber nicht wirklich " "praxisgerecht." #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" "struct init_request {\n" " int magic; /* Magische Zahl */\n" " int cmd; /* Art der Anfrage */\n" " int runlevel; /* Ziel-Runlevel */\n" " int sleeptime; /* Zeit zwischen TERM und KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 #, fuzzy #| msgid "The previous runlevel (useful after a runlevel switch)." msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "Der vorherige Runlevel (nützlich nach einer Änderung des Runlevels)." #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "/run/initctl /sbin/init" # FIXME superfluous whitespace #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "INITSCRIPT" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "10. Juli 2003" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "initscript - Skript, das Inittab-Befehle ausführt" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "/bin/sh /etc/initscript ID Runlevels Aktion Prozess" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" "Wenn das Shell-Skript I existiert, wird es von B " "verwendet, um Befehle aus I auszuführen. Dieses Skript kann " "verwendet werden, um für Parameter wie I und I für jeden " "Prozess Standardwerte festzulegen." #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" "Dies ist ein Beispiel, das auf Ihrem System als I " "installiert werden könnte." #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" "#\n" "# initscript Wird von init(8) für alle Programme, für die\n" "# ein Prozess erzeugt werden soll, wie folgt\n" "# ausgeführt:\n" "#\n" "# /bin/sh /etc/initscript EIDE ELevelE EAktionE EProzessE\n" "#\n" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" "# Umask auf einen sicheren Wert setzen und Speicherauszüge\n" "# nach Abstürzen (Core-Dumps) ermöglichen.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" "# Erhöht die absolute Obergrenze (hard limit) für Datei-\n" "# deskriptoren pro Prozess auf 8192. Die überschreitbare (weiche,\n" "# soft) Grenze ist immer noch 1024. Sie kann aber von jedem un-\n" "# privilegierten Prozess mittels »ulimit -Sn xxx« bis zur\n" "# Obergrenze heraufgesetzt werden. Dafür ist ein Kernel der\n" "# Version 2.2.13 oder höher erforderlich.\n" " ulimit-Hn 8192\n" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" "# das Programm ausführen\n" " eval exec \"$4\"\n" # FIXME B → I #. type: Plain text #: ../initscript.5:65 msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" "Dieses Skript ist nicht als Startup-Skript für Daemonen oder Dienste " "gemeint. Es hat nichts mit einem Skript im I-Stil zu tun. Es ist " "nur ein Handler für aus B heraus ausgeführte Arbeiten. Das " "Experimentieren damit kann bewirken, dass Ihr System nicht (mehr neu) " "starten kann." #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "/etc/inittab, /etc/initscript" #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "B(5), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "4. Dezember 2001" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" "inittab - Format der Datei inittab für den SysV-kompatiblen Init-Prozess" # FIXME file name markup #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" "Die Datei B beschreibt, welche Prozesse beim Booten und während des " "normalen Betriebs gestartet werden (z. B. \\& /etc/init.d/boot, /etc/init.d/" "rc, gettys …). B(8) unterscheidet mehrere I, von denen jeder " "einen eigenen Satz von Prozessen umfasst, die gestartet werden. Gültige " "Runlevel sind B<0>-B<6> plus B, B und B für B-Einträge. " "Ein Eintrag in der Datei B hat folgendes Format:" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "I:I:I:I" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "Zeilen mit einer Raute »#« am Anfang werden ignoriert." #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "I" # Zur Schreibweise: http://de.wikipedia.org/wiki/SysVinit #. type: Plain text #: ../inittab.5:48 msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" "ist eine eindeutige Folge von 1-4 Zeichen zur Identifikation eines Eintrags " "in B. (Für Versionen von SysVinit, die mit der I Libc5 " "(E 5.2.18) oder a.out-Bibliotheken kompiliert wurden, ist das Limit 2 " "Zeichen)." #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" "Hinweis: Traditionell ist für Getty und andere Anmeldeverfahren der Wert des " "I-Felds der gleiche wie die Endung des entsprechenden ttys gehalten, z." "B. \\& B<1> für B. Einige alte Anmeldeabrechnungsprogramme könnten das " "voraussetzen, obwohl der Verfasser sich keines vorstellen kann." #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "" "listet die Runlevel, für die die angegebene Aktion durchgeführt werden soll." #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "beschreibt, was getan werden soll." #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "I" #. }}} #. type: Plain text #: ../inittab.5:71 msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" "gibt an, welcher Prozess ausgeführt werden soll. Wenn das Prozess-Feld mit " "einem »+«-Zeichen beginnt, führt B(8) keine utmp- und wtmp-Abrechnung " "(accounting) für diesen Prozess. Dies ist für Gettys erforderlich, die " "darauf bestehen, das selber zu erledigen. Dies ist auch ein historischer " "Fehler. Die Länge dieses Feldes ist auf 127 Zeichen begrenzt." #. type: Plain text #: ../inittab.5:78 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" "Das Feld I kann mehrere Zeichen für verschiedene Runlevel " "enthalten. Beispielsweise legt B<123> fest, dass der Prozess in den " "Runleveln 1, 2 und 3 gestartet werden soll. Die Runlevel für B-" "Einträge können B, B oder B enthalten. Das Feld I der " "Einträge B, B und B wird ignoriert." #. type: Plain text #: ../inittab.5:82 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" "Bei einem Wechsel des Runlevels des Systems werden alle laufenden Prozesse, " "die nicht im neuen Runlevel laufen sollen, beendet; zuerst mit \\s-2SIGTERM" "\\s0, dann mit \\s-2SIGKILL\\s0." #. {{{ respawn #. type: Plain text #: ../inittab.5:85 msgid "Valid actions for the I field are:" msgstr "Gültige Einträge für das I-Feld sind:" #. type: IP #: ../inittab.5:85 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:89 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "" "Der Prozess wird jedesmal, wenn er terminiert, neu gestartet (z.B. \\& " "getty)." #. type: IP #: ../inittab.5:89 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:95 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" "Der Prozess wird einmal beim Eintritt in den Runlevel gestartet und " "B(8) wartet auf den Abschluss des Prozesses." #. type: IP #: ../inittab.5:95 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:100 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "" "Der Prozess wird einmal während der Initialisierung des Runlevels ausgeführt." #. type: IP #: ../inittab.5:100 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:105 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" "Der Prozess wird ausgeführt, während das System hochfährt. Das Feld " "I wird ignoriert." #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:112 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" "Der Prozess läuft während des Systemstarts und B(8) wartet auf seinen " "Abschluss (z. B.\\& /etc/rc). Das Feld I wird ignoriert." #. type: IP #: ../inittab.5:112 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:116 msgid "This does nothing." msgstr "Es wird keine Aktion durchgeführt." #. type: IP #: ../inittab.5:116 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:123 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" "Ein mit B gekennzeichneter Prozess wird jedesmal ausgeführt, wenn " "das angegebene B-Runlevel aufgerufen wird. Es erfolgt aber kein " "Wechsel des Runlevels. (Die B-Runlevel sind »a«, »b« und »c«.)" #. type: IP #: ../inittab.5:123 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:130 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" "Ein B-Eintrag legt den Runlevel nach dem Systemstart fest. " "Fehlt dieser Eintrag, wird B(8) auf der Konsole nach dem Runlevel " "fragen. Das I-Feld wird ignoriert." #. type: IP #: ../inittab.5:130 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:136 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" "Dieser Prozess läuft beim Systemstart vor den B- und B-" "Einträgen. Das Feld I wird ignoriert. " #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:142 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" "Dieser Prozess wird ausgeführt, wenn die Spannung der Stromversorgung sinkt. " "B(8) wird üblicherweise von einem Prozess informiert, der mit der USV " "kommuniziert. B(8) wartet das Ende dieses Prozesses ab, bevor es " "weiter macht." #. type: IP #: ../inittab.5:142 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:147 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" "Wie B; B(8) wartet aber nicht auf den Abschluss dieses " "Prozesses." #. type: IP #: ../inittab.5:147 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:152 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" "Dieser Prozess wird ausgeführt, sobald B(8) erfährt, dass die " "Spannungsversorgung wieder normal funktioniert. " #. type: IP #: ../inittab.5:152 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:158 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" "Dieser Prozess wird ausgeführt, wenn B(8) erfährt, dass die Batterie " "der externen USV fast leer ist und ein Stromausfall droht. Voraussetzung ist " "natürlich, dass USV und Überwachungsprozess diesen Zustand erkennen können." #. type: IP #: ../inittab.5:158 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:166 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" "Der Prozess wird ausgeführt, wenn B(8) das Signal B erhält. " "Dies bedeutet, dass jemand auf der System-Konsole die Tastenkombination " "B eingegeben hat. Normalerweise will man eine Art von " "B ausführen; entweder in den Single-User-Runlevel wechseln oder " "den Rechner neu starten." #. type: IP #: ../inittab.5:166 #, no-wrap msgid "B" msgstr "B" # Etwas freier #. type: Plain text #: ../inittab.5:170 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" "Der Prozess wird ausgeführt, wenn der Tastatur-Handler B(8) " "signalisiert, dass auf der Tastatur der Konsole eine bestimmte " "Tastenkombination eingegeben wurde." #. type: Plain text #: ../inittab.5:176 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" "Die Dokumentation für diese Funktion ist noch nicht vollständig. Zusätzliche " "Dokumentation finden Sie in den kbd-x.xx-Paketen (das aktuellste war beim " "Schreiben dieser Handbuchseite kbd-0.94). Wahrscheinlich möchten Sie der " "»KeyboardSignal«-Aktion eine Tastenkombinationen zuordnen. Um beispielsweise " "die Kombination »Alt Aufwärtspfeil« zu verwenden, tragen Sie in Ihre keymaps-" "Datei ein:" #. type: Plain text #: ../inittab.5:179 msgid "alt keycode 103 = KeyboardSignal" msgstr "alt keycode 103 = KeyboardSignal" #. type: Plain text #: ../inittab.5:186 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "" "Dies ist ein Beispiel für eine inittab, die der alten Linux-inittab ähnelt:" #. type: Plain text #: ../inittab.5:197 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" "# inittab für Linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" #. type: Plain text #: ../inittab.5:202 msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" "Diese inittab-Datei führt beim Systemstart I aus und startet Gettys " "auf tty1 bis tty4." #. type: Plain text #: ../inittab.5:205 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" "Eine ausgefeiltere B mit verschiedenen Runleveln (siehe die " "innenstehenden Kommentare):" #. type: Plain text #: ../inittab.5:211 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" "# Standard-Runlevel\n" "id:2:initdefault:\n" #. type: Plain text #: ../inittab.5:214 #, no-wrap msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" "# Skript für Konfiguration/Initialisierung während\n" "# des Systemstarts\n" "si::sysinit:/etc/init.d/rcS\n" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" "# Das läuft im Single-User-Modus.\n" "~:S:wait:/sbin/sulogin\n" #. type: Plain text #: ../inittab.5:225 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" "# /etc/init.d führt beim Wechsel des Runlevel die\n" "# S- und K-Skripte aus.\n" "#\n" "# Runlevel 0 ist Halt.\n" "# Runlevel 1 ist der Single-User-Betrieb.\n" "# Runlevel 2-5 sind Mehrbenutzer-Modi.\n" "# Runlevel 6 ist der Neustart (Reboot).\n" #. type: Plain text #: ../inittab.5:233 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:236 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" "# Was wird beim »Affengriff« getan?\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" "# Runlevel 2,3: Getty auf virtuellen Konsolen\n" "# Runlevel 3: Getty auf Terminal (ttyS0) und Modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:255 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:270 msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "Der Autor von B(8) ist E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> Diese Handbuchseite wurde von E<.MT lederer@\\:francium" "\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> geschrieben und " "von E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> Michael Haardt " "E<.ME> überarbeitet." #. type: Plain text #: ../inittab.5:272 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "KILLALL5" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "4. November 2003" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "killall5 - ein Signal an alle Prozesse senden" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" #. type: IP #: ../killall5.8:35 #, no-wrap msgid "B<-o> I" msgstr "B<-o> I" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "weist B an, Prozesse mit dieser Kennung (PID) zu übergehen." #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" "B kann auch als B(8) aufgerufen werden, welches einfach ein " "(symbolischer) Link auf das Programm B ist." #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" "Das Programm gibt 0 zurück, wenn Prozesse abgewürgt werden konnten. Es gibt " "2 zurück, wenn kein Prozess abgewürgt wurde, und 1, wenn keine Prozesse " "gefunden werden konnten (I fehlt)." #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "B(8), B(8), B(8)" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "LAST," #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "1" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "31. Juli 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "last, lastb - eine Liste der zuletzt angemeldeten Benutzer anzeigen" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" #. type: Plain text #: ../last.1:56 #, fuzzy #| msgid "" #| "B searches back through the I file (or the file " #| "designated by the B<-f> option) and displays a list of all users logged " #| "in (and out) since that file was created. One or more I and/" #| "or I can be given, in which case B will show only the entries " #| "matching those arguments. Names of I can be abbreviated, thus " #| "B is the same as B." msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" "B durchsucht die Datei I (oder die durch die Option B<-" "f> angegebene Datei) rückwärts und zeigt eine Liste aller Benutzer an, die " "sich seit der Erstellung der Datei angemeldet (und abgemeldet) haben. Einer " "oder mehrere I und/oder I können angegeben werden, in " "welchem Fall B nur die Einträge anzeigt, die auf diese Argumente " "passen. Die Namen der I können abgekürzt werden, daher ist B " "gleichbedeutend mit B." #. type: Plain text #: ../last.1:61 msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" "Wenn eine B-Signalerbrechungstastenkombination (üblicherweise mit " "Strg-C erzeugt) oder ein B-Signal (üblicherweise mit Strg-\\e " "erzeugt) empfangen wird, zeigt B an, wie weit die Suche durch die " "Datei bereits fortgeschritten ist; im Falle des B-Signals wird " "B dann beeendet." #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "" "Der Pseudo-Benutzer B meldet sich jedesmal an, wenn das System neu " "gestartet wird. Daher zeigt B ein Protokoll aller Neustarts " "seit der Erstellung der Protokolldatei an." #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" "B ist gleichbedeutend mit B, außer dass es in der " "Voreinstellung ein Protokoll aus der Datei I anzeigt, welches " "die fehlgeschlagenen Anmeldeversuche enthält." #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "B<-f> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" "weist B an, eine spezifische Datei anstelle von I zu " "verwenden." #. type: IP #: ../last.1:73 #, no-wrap msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 msgid "This is a count telling B how many lines to show." msgstr "weist B an, wie viele Zeilen es anzeigen soll." #. type: IP #: ../last.1:75 #, no-wrap msgid "B<-n> I" msgstr "B<-n> I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "Das gleiche." #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "B<-t> I" #. type: Plain text #: ../last.1:82 msgid "" "Display the state of logins as of the specified time. This is useful, e.g., " "to determine easily who was logged in at a particular time -- specify that " "time with B<-t> and look for \"still logged in\"." msgstr "" "zeigt den Status der Anmeldungen zur angegebenen I an. Dies ist " "beispielsweise nützlich, um zu ermitteln, wer zu einem bestimmten Zeitpunkt " "angemeldet war. Geben Sie diese Zeit mit B<-t> an und schauen Sie nach " "»still logged in«." #. type: IP #: ../last.1:82 #, no-wrap msgid "B<-R>" msgstr "B<-R>" #. type: Plain text #: ../last.1:84 msgid "Suppresses the display of the hostname field." msgstr "unterdrückt die Ausgabe des Rechnernamenfeldes." #. {{{ -a #. type: IP #: ../last.1:84 ../logsave.8:40 ../shutdown.8:56 #, no-wrap msgid "B<-a>" msgstr "B<-a>" #. type: Plain text #: ../last.1:87 msgid "" "Display the hostname in the last column. Useful in combination with the next " "flag." msgstr "" "zeigt den Rechnernamen in der letzten Spalte an. Dies ist in Kombination mit " "der nächsten Option nützlich." #. type: Plain text #: ../last.1:91 msgid "" "For non-local logins, Linux stores not only the host name of the remote host " "but its IP number as well. This option translates the IP number back into a " "hostname." msgstr "" "übersetzt die IP-Nummer zurück in einen Rechnernamen. Bei nichtlokalen " "Anmeldungen speichert Linux nicht nur den Namen des fernen Rechners, sondern " "auch dessen IP-Nummer." #. type: IP #: ../last.1:91 ../shutdown.8:91 #, no-wrap msgid "B<-F>" msgstr "B<-F>" #. type: Plain text #: ../last.1:93 msgid "Print full login and logout times and dates." msgstr "gibt die vollständigen Zeiten und Daten der An- und Abmeldungen aus." #. type: Plain text #: ../last.1:96 msgid "" "This option is like B<-d> in that it displays the IP number of the remote " "host, but it displays the IP number in numbers-and-dots notation." msgstr "" "entspricht B<-d> insoweit, dass es die IP des fernen Rechners anzeigt, aber " "in einer Ziffer-Punkt-Notation." #. type: IP #: ../last.1:96 #, no-wrap msgid "B<-l>" msgstr "B<-l>" #. type: Plain text #: ../last.1:100 msgid "" "This option allows the display of usernames longer than 8 characters. This " "may mess up formatting in some programs and make the output wider than the " "standard 80 characters." msgstr "" #. type: IP #: ../last.1:100 ../utmpdump.1:33 #, no-wrap msgid "B<-o>" msgstr "B<-o>" #. type: Plain text #: ../last.1:102 msgid "Read an old-type wtmp file (written by linux-libc5 applications)." msgstr "" "liest eine Wtmp-Datei des alten Typs (von linux-libc5-Anwendungen " "geschrieben)." #. type: Plain text #: ../last.1:104 msgid "Display full user and domain names in the output." msgstr "zeigt die vollständigen Benutzer- und Domainnamen in der Ausgabe an." #. type: IP #: ../last.1:104 ../mountpoint.1:40 ../pidof.8:63 #, no-wrap msgid "B<-x>" msgstr "B<-x>" #. }}} #. type: Plain text #: ../last.1:107 msgid "Display the system shutdown entries and run level changes." msgstr "" "zeigt die Einträge zum Herunterfahren und zu den Runlevel-Änderungen des " "Systems an." #. {{{ Files #. type: Plain text #: ../last.1:114 msgid "" "The files I and I might not be found. The system only logs " "information in these files if they are present. This is a local " "configuration issue. If you want the files to be used, they can be created " "with a simple B(1) command (for example, B)." msgstr "" "Die Dateien I und I könnten nicht gefunden werden. Das System " "protokolliert nur Informationen in diesen Dateien, wenn diese vorhanden " "sind. Dies ist ein Problem der lokalen Konfiguration. Wenn Sie diese Dateien " "verwenden wollen, können sie mit dem einfachen Befehl B(1) angelegt " "werden (zum Beispiel B)." #. type: Plain text #: ../last.1:116 msgid "/var/log/wtmp" msgstr "/var/log/wtmp" #. }}} #. {{{ Author #. type: Plain text #: ../last.1:120 msgid "/var/log/btmp" msgstr "/var/log/btmp" #. type: Plain text #: ../last.1:129 msgid "B(8), B(1), B(8)" msgstr "B(8), B(1), B(8)" #. type: TH #: ../logsave.8:5 #, no-wrap msgid "LOGSAVE" msgstr "LOGSAVE" #. type: Plain text #: ../logsave.8:8 msgid "logsave - save the output of a command in a logfile" msgstr "logsave - die Ausgabe eines Befehls in einer Protokolldatei speichern" #. type: Plain text #: ../logsave.8:14 msgid "B [ B<-asv> ] I" msgstr "B [ B<-asv> ] I" #. type: Plain text #: ../logsave.8:27 msgid "" "The B program will execute I with the specified " "argument(s), and save a copy of its output to I. If the containing " "directory for I does not exist, B will accumulate the " "output in memory until it can be written out. A copy of the output will " "also be written to standard output." msgstr "" "Das Programm B führt den einen I mit den angegebenen " "Argumenten aus und speichert eine Kopie der Ausgabe in die " "I. Falls das Verzeichnis für die I nicht " "existiert, sammelt B die Ausgabe im Speicher, bis die Datei " "geschrieben werden kann. Außerdem wird eine Kopie der Ausgabe in die " "Standardausgabe gschrieben." #. type: Plain text #: ../logsave.8:34 msgid "" "If I is a single hyphen ('-'), then instead of executing a " "program, B will take its input from standard input and save it in " "I." msgstr "" "Falls das Programm als einzelnes Minuszeichen (»-«) angegeben wird, dann " "bezieht B seine Eingabe aus der Standardeingabe, anstatt ein " "Programm auszuführen, und speichert die Ausgabe in der I." #. type: Plain text #: ../logsave.8:39 msgid "" "B is useful for saving the output of initial boot scripts until the " "I partition is mounted, so the output can be written to I." msgstr "" "B eignet sich zum Speichern der Ausgaben initialer Boot-Skripte, " "bis die I-Partition eingehängt ist und die Ausgabe in I " "geschrieben werden kann." #. type: Plain text #: ../logsave.8:45 msgid "" "This option will cause the output to be appended to I, instead of " "replacing its current contents." msgstr "" "bewirkt, dass die Ausgabe an die I angehängt wird, anstatt " "deren momentanen Inhalt zu ersetzen." #. type: Plain text #: ../logsave.8:53 msgid "" "This option will cause B to skip writing to the log file text which " "is bracketed with a control-A (ASCII 001 or Start of Header) and control-B " "(ASCII 002 or Start of Text). This allows progress bar information to be " "visible to the user on the console, while not being written to the log file." msgstr "" #. type: Plain text #: ../logsave.8:58 msgid "" "This option will make B to be more verbose in its output to the " "user." msgstr "bewirkt, dass die Ausgaben von B ausführlicher werden." #. type: Plain text #: ../logsave.8:62 msgid "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" msgstr "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" #. type: Plain text #: ../logsave.8:63 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "MESG" msgstr "MESG" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "Feb 26, 2001" msgstr "26. Februar 2001" #. type: TH #: ../mesg.1:20 ../mountpoint.1:18 ../readbootlog.1:20 ../utmpdump.1:18 #: ../wall.1:18 #, no-wrap msgid "User Commands" msgstr "Dienstprogramme für Benutzer" #. }}} #. {{{ Synopsis #. type: Plain text #: ../mesg.1:27 msgid "mesg - control write access to your terminal" msgstr "mesg - den Schreibzugriff auf Ihr Terminal steuern" #. }}} #. {{{ Description #. type: Plain text #: ../mesg.1:32 msgid "B [B|B]" msgstr "B [B|B]" #. }}} #. {{{ Options #. type: Plain text #: ../mesg.1:38 msgid "" "B controls the access to your terminal by others. It's typically used " "to allow or disallow other users to write to your terminal (see B(1))." msgstr "" "B steuert den Zugriff auf Ihr Terminal durch andere. Es wird " "üblicherweise dazu verwendet, anderen Benutzern entweder zu gestatten oder " "zu verbieten, auf Ihr Terminal zu schreiben (siehe B(1))." #. type: IP #: ../mesg.1:39 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:41 msgid "Allow write access to your terminal." msgstr "erlaubt den Schreibzugriff auf Ihr Terminal." #. type: IP #: ../mesg.1:41 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:43 msgid "Disallow write access to your terminal." msgstr "verbietet den Schreibzugriff auf Ihr Terminal." #. }}} #. {{{ Notes #. type: Plain text #: ../mesg.1:48 msgid "" "If no option is given, B prints out the current access state of your " "terminal." msgstr "" "Falls keine Argumente angegeben sind, zeigt B den aktuellen Status des " "Zugriffs auf Ihr Terminal an." # FIXME mesg → B #. type: Plain text #: ../mesg.1:53 msgid "" "B assumes that its standard input is connected to your terminal. That " "also means that if you are logged in multiple times, you can get/set the " "mesg status of other sessions by using redirection. For example \"mesg n " "E /dev/pts/46\"." msgstr "" "B geht davon aus, dass seine Standardeingabe mit Ihrem Terminal " "verbunden ist. Das bedeutet auch, falls Sie mehrfach angemeldet sind, den " "B-Status anderer Sitzungen durch Umleitung abfragen oder setzen " "können. Zum Beispiel »mesg n E /dev/pts/46«." #. type: Plain text #: ../mesg.1:62 msgid "B(1), B(1), B(1)" msgstr "B(1), B(1), B(1)" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "MOUNTPOINT" msgstr "MOUNTPOINT" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "Mar 15, 2004" msgstr "15. Mai 2004" #. type: Plain text #: ../mountpoint.1:21 msgid "mountpoint - see if a directory is a mountpoint" msgstr "mountpoint - überprüfen, ob ein Verzeichnis ein Einhängepunkt ist" #. type: Plain text #: ../mountpoint.1:26 msgid "B [B<-q>] [B<-d>] I" msgstr "B [B<-q>] [B<-d>] I" #. type: Plain text #: ../mountpoint.1:30 msgid "B B<-x> I" msgstr "B B<-x> I" #. type: Plain text #: ../mountpoint.1:32 msgid "B checks if the directory is a mountpoint." msgstr "B überprüft, ob ein Verzeichnis ein Einhängepunkt ist." #. type: IP #: ../mountpoint.1:34 ../pidof.8:60 ../shutdown.8:107 #, no-wrap msgid "B<-q>" msgstr "B<-q>" #. type: Plain text #: ../mountpoint.1:36 msgid "Be quiet - don't print anything." msgstr "unterdrückt die Ausgaben." #. type: Plain text #: ../mountpoint.1:38 msgid "Print major/minor device number of the filesystem on stdout." msgstr "" "zeigt die Major/Minor-Gerätenummern des Dateisystems in der Standardausgabe " "an." #. type: Plain text #: ../mountpoint.1:40 msgid "" "Check Linux's I file to try to detect circular mount points." msgstr "" #. type: Plain text #: ../mountpoint.1:42 msgid "Print major/minor device number of the blockdevice on stdout." msgstr "" "zeigt die Major/Minor-Gerätenummer des angegebenen blockorientierten Geräts " "in der Standardausgabe an." #. type: Plain text #: ../mountpoint.1:44 msgid "Zero if the directory is a mountpoint, non-zero if not." msgstr "" "Null, falls das Verzeichnis ein Einhängepunkt ist, nicht Null, wenn nicht." #. type: Plain text #: ../mountpoint.1:48 msgid "" "Symbolic links are not followed, except when the B<-x> option is used. To " "force following symlinks, add a trailing slash to the path of the directory." msgstr "" "Symbolischen Links wird nur gefolgt, wenn die Option B<-x> angegeben wird. " "Um das Verfolgen von symbolischen Links zu erzwingen, hängen Sie einen " "Schrägstrich an den Pfad zum Verzeichnis an." #. type: Plain text #: ../mountpoint.1:52 msgid "" "The name of the command is misleading when the B<-x> option is used, but the " "option is useful for comparing if a directory and a device match up, and " "there is no other command that can print the info easily." msgstr "" "Der Name des Befehls ist irreführend, wenn die Option B<-x> verwendet wird, " "aber diese Option ist nützlich beim Vergleichen, ob ein Verzeichnis und ein " "Gerät zusammengehören. Es gibt keinen anderen Befehl, der dies so einfach " "ausgeben kann." # FIXME mountpoint → B # FIXME binded → bind-mounted #. type: Plain text #: ../mountpoint.1:57 msgid "" "The mountpoint command fails when a directory is binded to one of its " "grandparents. For example, if /a/b/c/d is a mount point for /a/b then " "mountpoint will report /a/b/c/d is not a valid mount point. This is because " "both the original directory and its new mount point share the same inode and " "device number." msgstr "" #. type: Plain text #: ../mountpoint.1:66 msgid "" "The circular mount problem can be worked around on Linux systems by using " "theB<-p> flag to check the I file for references to the " "circular mount bind. When using the B<-p> flag, make sure to specify the " "full path (ie I and not just I). Also, B may " "still fail if there are spaces in the mount point's path, even when using " "the B<-p> flag because of the way B mangles the spaces in the " "path name. Of course, if the admin is using circular mount points with " "spaces in the name, there are bigger concerns." msgstr "" #. type: Plain text #: ../mountpoint.1:71 msgid "B(1)" msgstr "B(1)" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "PIDOF" msgstr "PIDOF" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "01 Sep 1998" msgstr "1. September 1998" #. type: Plain text #: ../pidof.8:21 msgid "pidof - find the process ID of a running program" msgstr "pidof - die Prozesskennung eines laufenden Programms finden" #. type: Plain text #: ../pidof.8:36 msgid "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> I] [B<-o> I] [B<-d> I] I " "[I]" msgstr "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> I] [B<-o> I] [B<-d> " "I] I [I]" #. type: Plain text #: ../pidof.8:44 msgid "" "B finds the process id's (PIDs) of the named programs. It prints " "those id's on the standard output. This program is on some systems used in " "run-level change scripts, especially when the system has a I like " "I structure. In that case these scripts are located in I, " "where ? is the runlevel. If the system has a B(8) program " "that should be used instead." msgstr "" #. type: Plain text #: ../pidof.8:47 msgid "Single shot - this instructs the program to only return one I." msgstr "" #. type: Plain text #: ../pidof.8:51 msgid "" "Only return process PIDs that are running with the same root directory. " "This option is ignored for non-root users, as they will be unable to check " "the current root directory of processes they do not own." msgstr "" #. type: Plain text #: ../pidof.8:60 msgid "" "Avoid B(2) system function call on all binaries which are located on " "network based file systems like B. Instead of using this option the " "variable B may be set and exported." msgstr "" #. type: Plain text #: ../pidof.8:63 msgid "" "Do not display matched PIDs to standard out. Simply exit with a status of " "true or false to indicate whether a matching PID was found." msgstr "" #. type: Plain text #: ../pidof.8:66 msgid "" "Scripts too - this causes the program to also return process id's of shells " "running the named scripts." msgstr "" #. type: IP #: ../pidof.8:66 #, no-wrap msgid "B<-z>" msgstr "B<-z>" #. type: Plain text #: ../pidof.8:73 msgid "" "Try to detect processes which are stuck in zombie (Z) status. Usually these " "processes are skipped as trying to deal with them can cause pidof or related " "tools to hang. Note: In the past pidof would ignore processes in the " "uninterruptable state (D), unless the B<-z> flag was specified. This is no " "longer the case. The B program will find and report processes in the " "D state whether B<-z> is specified or not." msgstr "" # FIXME missing markup #. type: IP #: ../pidof.8:73 #, no-wrap msgid "-d I" msgstr "-d I" # FIXME I → B #. type: Plain text #: ../pidof.8:76 msgid "" "Tells I to use I as an output separator if more than one PID is " "shown. The default separator is a space." msgstr "" "weist B an, den angegebenen I für die Ausgabe zu verwenden, " "falls mehr als eine PID angezeigt wird. Der vorgegebene Trenner ist ein " "Leerzeichen." # FIXME -o → B<-o> #. type: IP #: ../pidof.8:76 #, no-wrap msgid "-o I" msgstr "-o I" # FIXME I → B #. type: Plain text #: ../pidof.8:80 msgid "" "Tells I to omit processes with that process id. The special pid B<" "%PPID> can be used to name the parent process of the B program, in " "other words the calling shell or shell script." msgstr "" "weist B an, Prozesse mit dieser Kennung (PID) zu übergehen. Mit der " "speziellen PID B<%PPID> können Sie den Namen des Elternprozesses des " "Programms B benennen, mit anderen Worten, die aufrufende Shell oder " "das Shell-Skript." #. type: TP #: ../pidof.8:81 #, no-wrap msgid "B<0>" msgstr "B<0>" #. type: Plain text #: ../pidof.8:84 msgid "At least one program was found with the requested name." msgstr "Es wurde mindestens ein Programm mit dem angegebenen Namen gefunden." #. type: TP #: ../pidof.8:84 #, no-wrap msgid "B<1>" msgstr "B<1>" #. type: Plain text #: ../pidof.8:87 msgid "No program was found with the requested name." msgstr "Es wurde kein Programm mit dem angegebenen Namen gefunden." # FIXME I → B #. type: Plain text #: ../pidof.8:90 msgid "" "I is actually the same program as B(8); the program behaves " "according to the name under which it is called." msgstr "" "B ist eigentlich das gleiche Programm wie B(8). Das " "Programm verhält sich nur unterschiedlich, je nachdem, unter welchem Namen " "es aufgerufen wird." #. type: Plain text #: ../pidof.8:98 msgid "" "When B is invoked with a full pathname to the program it should find " "the pid of, it is reasonably safe. Otherwise it is possible that it returns " "PIDs of running programs that happen to have the same name as the program " "you're after but are actually other programs. Note that the executable name " "of running processes is calculated with B(2), so symbolic links to " "executables will also match." msgstr "" #. type: Plain text #: ../pidof.8:103 msgid "" "Zombie processes or processes in disk sleep (states Z and D, respectively) " "are ignored, as attempts to access the stats of these will sometimes fail. " "The B<-z> flag (see above) tells B to try to detect these sleeping " "and zombie processes, at the risk of failing or hanging." msgstr "" #. type: Plain text #: ../pidof.8:110 msgid "B(8), B(8), B(8), B(8), B(8)" msgstr "B(8), B(8), B(8), B(8), B(8)" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "READBOOTLOG" msgstr "READBOOTLOG" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "NOV 12, 2018" msgstr "12. November 2018" #. }}} #. {{{ Synopsis #. type: Plain text #: ../readbootlog.1:27 msgid "" "readbootlog - show contents of the boot log, stripping away control " "characters" msgstr "readbootlog - Inhalt des Bootprotokolls ohne Steuerzeichen anzeigen" #. type: Plain text #: ../readbootlog.1:31 msgid "B [B<-h>] [-B I]" msgstr "B [B<-h>] [-B I]" #. }}} #. {{{ Options #. type: Plain text #: ../readbootlog.1:42 msgid "" "B is a tool for reading the boot log (by default I). The program strips away control characters and non-human readable " "contents from the log file. Output is dumped to the terminal where it can be " "piped or redirected to a file." msgstr "" #. type: Plain text #: ../readbootlog.1:45 msgid "" "Tells B to use a specific file instead of I." msgstr "" #. {{{ Files #. type: Plain text #: ../readbootlog.1:48 msgid "Displays a brief help message." msgstr "zeigt eine kurze Hilfemeldung an." #. }}} #. {{{ Author #. type: Plain text #: ../readbootlog.1:52 msgid "/var/log/boot" msgstr "/var/log/boot" #. }}} #. {{{ See also #. type: Plain text #: ../readbootlog.1:58 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" #. type: Plain text #: ../readbootlog.1:59 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "RUNLEVEL" msgstr "RUNLEVEL" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "May 27, 1997" msgstr "27. Mai 1997" # FIXME -- → - #. type: Plain text #: ../runlevel.8:21 msgid "runlevel - find the previous and current system runlevel" msgstr "" "runlevel - den vorhergehenden und aktuellen Runlevel des Systems ausgeben" #. type: Plain text #: ../runlevel.8:24 msgid "B [I]" msgstr "B [I]" #. type: Plain text #: ../runlevel.8:34 msgid "" "B reads the system I file (typically I) to " "locate the runlevel record, and then prints the previous and current system " "runlevel on its standard output, separated by a single space. If there is no " "previous system runlevel, the letter B will be printed instead." msgstr "" "B liest die I-Datei des Systems (typischerweise I), um den Runlevel zu ermitteln und dann den vorherigen und aktuellen " "Runlevel, durch ein einzelnes Leerzeichen getrennt, in die Standardausgabe " "zu schreiben. Gibt es keinen vorherigen Runlevel, wird stattdessen der " "Buchstabe B ausgegeben." #. type: Plain text #: ../runlevel.8:42 msgid "" "If no I file exists, and if no runlevel record can be found in the I file, B prints the word B and exits " "with an error." msgstr "" "Falls keine I-Datei existiert und kein Runlevel in der Datei I vermerkt ist, gibt B das Wort B aus und " "beendet sich mit einem Fehler." # FIXME B → B #. type: Plain text #: ../runlevel.8:49 msgid "" "B can be used in I scripts as a substitute for the System-V " "B command. However, in newer versions of B(8) this " "information is also available in the environment variables B and " "B." msgstr "" "B kann in I-Skripten als Ersatz für den System-V-Befehl B verwendet werden. Allerdings steht diese Information in neueren Versionen " "von B(8) in den Umgebungsvariablen B und B zur " "Verfügung." #. {{{ utmp #. type: IP #: ../runlevel.8:51 #, no-wrap msgid "I" msgstr "I" #. }}} #. type: Plain text #: ../runlevel.8:54 msgid "The name of the I file to read." msgstr "gibt den Namen der zu lesenden I-Datei an." #. type: Plain text #: ../runlevel.8:57 msgid "B(8), B(5)" msgstr "B(8), B(5)" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "SHUTDOWN" msgstr "SHUTDOWN" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "November 12, 2003" msgstr "12. November 2003" #. }}} #. {{{ Synopsis #. type: Plain text #: ../shutdown.8:27 msgid "shutdown - bring the system down" msgstr "shutdown - das System herunterfahren" #. }}} #. {{{ Description #. type: Plain text #: ../shutdown.8:36 msgid "" "B [B<-akrhPHfFncqQ>] [B<-t> I] I,B,B" #~ msgstr "B,B,B" #~ msgid "Jesse Smith Ejsmith@resonatingmedia.comE" #~ msgstr "Jesse Smith Ejsmith@resonatingmedia.comE" #~ msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg ,Emiquels@cistron.nlE" # FIXME missing whitespace #, no-wrap #~ msgid "LAST,LASTB" #~ msgstr "LAST, LASTB" # FIXME unused variables #, no-wrap #~ msgid "@E2FSPROGS_MONTH@ @E2FSPROGS_YEAR@" #~ msgstr "@E2FSPROGS_MONTH@ @E2FSPROGS_YEAR@" # FIXME unused variables #, no-wrap #~ msgid "E2fsprogs version @E2FSPROGS_VERSION@" #~ msgstr "E2fsprogs Version @E2FSPROGS_VERSION@" # FIXMe missing markup #~ msgid "Theodore Ts'o (tytso@mit.edu)" #~ msgstr "Theodore Ts'o Etytso@mit.eduE" #, no-wrap #~ msgid "Linux User's Manual" #~ msgstr "Linux-Benutzerhandbuch" # FIXME missing markup #~ msgid "Miquel van Smoorenburg (miquels@cistron.nl)" #~ msgstr "Miquel van Smoorenburg Emiquels@cistron.nlE" # FIXME missing markup #, no-wrap #~ msgid "-s" #~ msgstr "-s" # FIXME missing markup #, no-wrap #~ msgid "-c" #~ msgstr "-c" # FIXME missing markup #, no-wrap #~ msgid "-n" #~ msgstr "-n" # FIXME missing markup #, no-wrap #~ msgid "-q" #~ msgstr "-q" # FIXME missing markup #, no-wrap #~ msgid "-x" #~ msgstr "-x" # FIXME missing markup #, no-wrap #~ msgid "-z" #~ msgstr "-z" # FIXME markup file name #, fuzzy #~| msgid "" #~| "B looks for the environment variable B or B " #~| "to determine what shell to start. If the environment variable is not " #~| "set, it will try to execute root's shell from I. If that " #~| "fails, it will fall back to I." #~ msgid "" #~ "I looks for the environment variable B or B to " #~ "determine what shell to start. If the environment variable is not set, it " #~ "will try to execute root's shell from /etc/passwd. If that fails it will " #~ "fall back to B." #~ msgstr "" #~ "B schaut nach der Umgebungsvariable B oder B, " #~ "um zu bestimmen, welche Shell gestartet werden soll. Falls die " #~ "Umgebungsvariable nicht gesetzt ist, versucht es, die Shell des Root-" #~ "Benutzers aus I zu starten. Falls dies fehlschlägt, fällt es " #~ "auf I zurück." #~ msgid "Miquel van Smoorenburg Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg Emiquels@cistron.nlE" #, no-wrap #~ msgid "systemd 249" #~ msgstr "systemd 249" #, no-wrap #~ msgid "halt" #~ msgstr "halt" #~ msgid "B [OPTIONS...]" #~ msgstr "B [OPTIONEN…]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [OPTIONEN…]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [OPTIONEN…]" #~ msgid "" #~ "B, B, B may be used to halt, power-off, or reboot " #~ "the machine\\&. All three commands take the same options\\&." #~ msgstr "" #~ "B, B, B kann zum Herunterfahren, Ausschalten oder " #~ "Neustarten der Maschine verwandt werden\\&. Alle drei Befehle akzeptieren " #~ "die gleichen Optionen\\&." #~ msgid "The following options are understood:" #~ msgstr "Die folgenden Optionen werden verstanden:" #~ msgid "B<--help>" #~ msgstr "B<--help>" #~ msgid "Print a short help text and exit\\&." #~ msgstr "Zeigt einen kurzen Hilfetext an und beendet das Programm\\&." #~ msgid "B<--halt>" #~ msgstr "B<--halt>" #~ msgid "" #~ "Halt the machine, regardless of which one of the three commands is invoked" #~ "\\&." #~ msgstr "" #~ "Die Maschine anhalten, unabhängig davon, welcher der drei Befehle " #~ "aufgerufen wurde\\&." #~ msgid "B<-p>, B<--poweroff>" #~ msgstr "B<-p>, B<--poweroff>" #~ msgid "" #~ "Power-off the machine, regardless of which one of the three commands is " #~ "invoked\\&." #~ msgstr "" #~ "Die Maschine ausschalten, unabhängig davon, welcher der drei Befehle " #~ "aufgerufen wurde\\&." #~ msgid "B<--reboot>" #~ msgstr "B<--reboot>" #~ msgid "" #~ "Reboot the machine, regardless of which one of the three commands is " #~ "invoked\\&." #~ msgstr "" #~ "Die Maschine neustarten, unabhängig davon, welcher der drei Befehle " #~ "aufgerufen wurde\\&." #~ msgid "B<-f>, B<--force>" #~ msgstr "B<-f>, B<--force>" #~ msgid "" #~ "Force immediate halt, power-off, or reboot\\&. When specified once, this " #~ "results in an immediate but clean shutdown by the system manager\\&. When " #~ "specified twice, this results in an immediate shutdown without contacting " #~ "the system manager\\&. See the description of B<--force> in " #~ "B(1) for more details\\&." #~ msgstr "" #~ "Erzwingt sofortiges Anhalten, Ausschalten oder Neustarten\\&. Wird dies " #~ "einmal angegeben, führt dies zu einem sofortigen aber sauberen " #~ "Herunterfahren durch den Systemverwalter\\&. Bei doppelter Angabe führt " #~ "dies zu einem sofortigen Herunterfahren ohne Kontakt zum Diensteverwalter" #~ "\\&. Lesen Sie die Beschreibung von B<--force> in B(1) für " #~ "weitere Details\\&." #~ msgid "B<-w>, B<--wtmp-only>" #~ msgstr "B<-w>, B<--wtmp-only>" #~ msgid "" #~ "Only write wtmp shutdown entry, do not actually halt, power-off, reboot" #~ "\\&." #~ msgstr "" #~ "Nur einen Wtmp-Herunterfahreintrag schreiben, nicht tatsächlich die " #~ "Maschine anhalten, ausschalten oder neustarten\\&." #~ msgid "B<-d>, B<--no-wtmp>" #~ msgstr "B<-d>, B<--no-wtmp>" #~ msgid "B<-n>, B<--no-sync>" #~ msgstr "B<-n>, B<--no-sync>" #~ msgid "" #~ "Don\\*(Aqt sync hard disks/storage media before halt, power-off, reboot" #~ "\\&." #~ msgstr "" #~ "Die Festplatte/das Speichermedium nicht vor dem Herunterfahren, " #~ "Ausschalten oder Neustarten synchronisieren\\&." #~ msgid "B<--no-wall>" #~ msgstr "B<--no-wall>" #~ msgid "Do not send wall message before halt, power-off, reboot\\&." #~ msgstr "" #~ "Keine Wall-Nachrichten vor dem Anhalten, Herunterfahren oder Neustarten " #~ "senden\\&." #~ msgid "On success, 0 is returned, a non-zero failure code otherwise\\&." #~ msgstr "" #~ "Bei Erfolg wird 0 zurückgegeben, anderenfalls ein Fehlercode ungleich Null" #~ "\\&." #~ msgid "" #~ "These commands are implemented in a way that preserves basic " #~ "compatibility with the original SysV commands\\&. B(1) verbs " #~ "B, B, B provide the same functionality with some " #~ "additional features\\&." #~ msgstr "" #~ "Diese Befehle sind auf eine Art implementiert, die die grundlegende " #~ "Kompatibilität zu den ursprünglichen SysV-Befehlen erhalten\\&. Die " #~ "Unterbefehle B, B, B von B(1) stellen " #~ "die gleichen Funktionalitäten mit zusätzlichen Funktionen bereit\\&." #~ msgid "" #~ "Note that on many SysV systems B used to be synonymous to " #~ "B, i\\&.e\\&. both commands would equally result in powering " #~ "the machine off\\&. systemd is more accurate here, and B results in " #~ "halting the machine only (leaving power on), and B is required " #~ "to actually power it off\\&." #~ msgstr "" #~ "Beachten Sie, dass viele SysV-Systeme B als Synonym zu B " #~ "verwendet haben, das heißt, dass beide Befehle gleichermaßen ein " #~ "Ausschalten des Systems bewirken würden\\&. Systemd ist hier genauer: " #~ "B bewirkt nur ein Anhalten der Maschine (die eingeschaltet bleibt) " #~ "und B ist nötig, um sie tatsächlich auszuschalten\\&." #~ msgid "B(1), B(1), B(8), B(1)" #~ msgstr "B(1), B(1), B(8), B(1)" #, no-wrap #~ msgid "systemd 250" #~ msgstr "systemd 250" # FIXME: somesuch sounds strange #~ msgid "" #~ "This script is not meant as startup script for daemons or somesuch. It " #~ "has nothing to do with a I style script. It's just a handler " #~ "for things executed from B. Experimenting with this can " #~ "make your system un(re)bootable." #~ msgstr "" #~ "Dieses Skript ist nicht als Startup-Skript für Daemonen oder so etwas " #~ "gemeint. Es hat nichts mit einem Skript im I-Stil zu tun. Es " #~ "ist nur ein Handler für aus B heraus ausgeführte Arbeiten. " #~ "Das Experimentieren damit kann bewirken, dass Ihr System nicht (mehr neu) " #~ "starten kann." #, no-wrap #~ msgid "2021-06-02" #~ msgstr "2. Juni 2021" #, no-wrap #~ msgid "util-linux 2.37.2" #~ msgstr "util-linux 2.37.2" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [Optionen] [I…] [I…]" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [Optionen] [I…] [I…]" #~ msgid "" #~ "B searches back through the I file (or the file " #~ "designated by the B<-f> option) and displays a list of all users logged " #~ "in (and out) since that file was created. One or more I and/or " #~ "I can be given, in which case B will show only the entries " #~ "matching those arguments. Names of I can be abbreviated, thus " #~ "B is the same as B." #~ msgstr "" #~ "B durchsucht die Datei I (oder die durch die Option " #~ "B<-f> angegebene Datei) rückwärts und zeigt eine Liste aller Benutzer an, " #~ "die sich seit der Erstellung der Datei angemeldet (und abgemeldet) haben. " #~ "Einer oder mehrere I und/oder I können angegeben " #~ "werden, in welchem Fall B nur die Einträge anzeigt, die auf diese " #~ "Argumente passen. Die Namen der I können abgekürzt werden, daher " #~ "ist B gleichbedeutend mit B." #~ msgid "" #~ "When catching a B signal (generated by the interrupt key, usually " #~ "control-C) or a SIGQUIT signal, B will show how far it has searched " #~ "through the file; in the case of the B signal B will then " #~ "terminate." #~ msgstr "" #~ "Wenn eine B-Signalunterbrechungstastenkombination (üblicherweise " #~ "mit Strg-C erzeugt) oder ein B-Signal empfangen wird, zeigt " #~ "B an, wie weit die Suche durch die Datei bereits fortgeschritten " #~ "ist; im Falle des B-Signals wird B dann beeendet." #~ msgid "" #~ "The pseudo user B logs in each time the system is rebooted. Thus " #~ "B will show a log of all the reboots since the log file was " #~ "created." #~ msgstr "" #~ "Der Pseudo-Benutzer B meldet sich jedesmal an, wenn das System " #~ "neu gestartet wird. Daher zeigt B ein Protokoll aller " #~ "Neustarts seit der Erstellung der Protokolldatei an." #~ msgid "B<-a>, B<--hostlast>" #~ msgstr "B<-a>, B<--hostlast>" #~ msgid "B<-d>, B<--dns>" #~ msgstr "B<-d>, B<--dns>" #~ msgid "" #~ "Tell B to use a specific I instead of I. The " #~ "B<--file> option can be given multiple times, and all of the specified " #~ "files will be processed." #~ msgstr "" #~ "weist B an, eine bestimmte I anstelle von I " #~ "zu verwenden. Die Option B<--file> kann mehrfach angegeben werden, " #~ "wodurch alle angegebenen Dateien verarbeitet werden." #~ msgid "B<-F>, B<--fulltimes>" #~ msgstr "B<-F>, B<--fulltimes>" #~ msgid "B<-i>, B<--ip>" #~ msgstr "B<-i>, B<--ip>" # Müsste das nicht eigentlich IP-Adresse heißen? #~ msgid "" #~ "Like B<--dns ,> but displays the host\\(cqs IP number instead of the name." #~ msgstr "" #~ "wie B<--dns>, zeigt aber die IP-Adresse des Rechners anstelle des Namens " #~ "an." #~ msgid "B<->I; B<-n>, B<--limit> I" #~ msgstr "B<->I; B<-n>, B<--limit> I" #~ msgid "B<-p>, B<--present> I,B,B" msgid "B, B, B" msgstr "B,B,B" #. type: Plain text #: ../init.8:175 #, fuzzy #| msgid "" #| "tell B to process only those B file entries having " #| "runlevel B,B or B." msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" "indica a B que procese solo las entradas del fichero B " "que tengan nivel de ejecución B,B o B." #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "B o B" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "indica a B que re-examine el fichero I." #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "B o B" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "indica a B que cambie a modo monousuario." #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "B o B" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" "indica a B que reejecute él mismo (guardando el estado). No re-" "examining el fichero I. El nivel de ejecución debería ser uno " "de B, en otro caso la solicitud sería ignorada silenciosamente." #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" "B ptambién puede decir a B cuanto esperará entre los envíos a " "los procesos de las señales B y B. El valor por defecto " "es is 3 segundos, pero se puede cambiar con la opción B<-t>." #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" "B solo se puede llamar por usuarios con los privilegios apropiados." #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" "El binario B comprueba si es B o B mirando a su I; el id del proceso B real es siempre B<1>. De esto podemos " "concluir que en lugar de llamar a B se puede usar B en su " "lugar como abreviatura." #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "ENTORNO" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "B fija las siguientes variables de entorno para todos sus hijos:" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "I" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" "Como el nombre dice. Útil para determinar si un guión corre directamente de " "B." #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "El nivel actual de ejecución del sistema." #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "El nivel de ejecución previo (útil tras un cambio de nivel)." #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" "La consola del sistema. Esto realmente es heredado del núcleo; sin embargo " "si no está fijado B lo pondrá como I por defecto." #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "BANDERAS DE CARGA" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" "Es posible pasar un número de banderas a B desde el monitor de " "arranque (v.g. LILO o GRUB). B acepta las siguientes banderas:" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "B<-s, S, single>" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" "Arranque en modo monousuario. En este modo I se examina y los " "guiones de carga rc normalmente se ejecutan antes de que la shell del modo " "monousuario se inicie." #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "B<1-5>" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "Nivel de ejecución en el que arrancar." #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "B<-b, emergency>" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" "Carga directamente en una shell monousuario sin ejecutar cualquier otro " "guion de inicio." #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "B<-a, auto>" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "B<-z >I" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "INTERFAZ" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" "B escucha en un I en /dev, I, los mensajes. " "B usa esto para comunicar con B. La interfaz no está muy bien " "documentada o acabada. Quienes estén interesados debería estudiar el fichero " "I del subdirectorio I del código fuente de B." #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "SEÑALES" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "Init reacciona ante diversas señales:" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "" #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" "Al recibir esta señal, B cierra y reabre su fifo de de control B. Ess útil para los guiones de arranque cuando se vuelve a montar " "I." #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" "Normalmente el núcleo envía esta señal a B cuando se pulsa CTRL-ALT-" "SUPR. Esto activa la acción I." #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" "El núcleo envía esta señal cuado se pulsa la tecla I. " "Activa la acción I." #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "CONFORME A" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" "B es compatible con el init System V init. Funciona junto a los " "guiones de lso directorios I y I. Si su " "sistema usa esta convención, debería haber un fichero I en el " "directorio I que explica como funcionan estos guiones." #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "ARCHIVOS" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "AVISOS" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" "B supone que procesos y descendientes de procesos permanecen en el " "mismo grupo de procesos que se creó originalmente para ellos. Si los " "procesos cambian su grupo B no puede matarlos y v.d. puede acabar con " "dos procesos leyendo de una línea del terminal." #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" "Si B encuantra que está levantando continuamente una entrada, más de " "10 veces en dos minutos, supondrá que es un error en la cedena del mandato, " "genera un mensaje de error en la consola del sistema y rehusa levantar esta " "entrada hasta que hayan pasado 5 minutos o recibas una señal. Esto no " "previene de que se coma los recursos del sistema cuando alguien comete un " "error tipográfico en el fichero I o en el programa para el que " "se elimina la entrada." #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>, página de " "manual inicial por E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "INITCTL" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "13 de abril de 2018" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "/run/initctl" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 #, fuzzy #| msgid "The previous runlevel (useful after a runlevel switch)." msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "El nivel de ejecución previo (útil tras un cambio de nivel)." #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "/run/initctl /sbin/init" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "INITSCRIPT" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "10 de julio de 2003" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "initscript - guión que ejecuta órdenes inittab" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "/bin/sh /etc/initscript id niveles_de_ejecucion acción proceso" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" "Cuando el guión de entorno I existe, B lo usará para " "ejecutar órdenes para I. Este guión puede ser usado para cosas " "como, por ejemplo, colocar los valores por defecto I y I para " "cada proceso." #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" "Este es un ejemplo de initscript, que se podría instalar en tu sistema como " "I." #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" "#\n" "# initscript Ejecutado por init(8) para cada programa,\n" "# requiere un formato como el siguiente\n" "#\n" "# /bin/sh /etc/initscript EidE EnivelE EacciónE EprocesoE\n" "#\n" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" " # Colocamos umask para salvar el nivel, y permitir volcados de\n" " # memoria.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" " # Ejecutamos el programa.\n" " eval exec \"$4\"\n" #. type: Plain text #: ../initscript.5:65 msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "/etc/inittab, /etc/initscript." #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "B(5), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "4 de diciembre de 2001" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" "inittab - formato del fichero inittab usado por el proceso init compatible " "SysV" #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" "El fichero B describe qué procesos se inician en la carga y durante " "la operación normal (por ejemplo, \\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distingue múltiples I, cada " "uno de los cuales puede tener su propio conjunto de procesos que se inician. " "Los niveles de ejecución válidos son B<0>-B<6> más B, B y B para " "entradas B. Una entrada del fichero B tiene el " "siguiente formato:" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "I:I:I:I" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "Las líneas que comienzan con `#' se ignoran." #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:48 #, fuzzy #| msgid "" #| "is a unique sequence of 1-4 characters which identifies an entry in " #| "B (for versions of sysvinit compiled with libraries E 5.2.18 " #| "or a.out libraries the limit is 2 characters)." msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" "es una secuencia única de 1 a 4 caracteres que identifican una entrada de " "B (para las versiones de sysvinit compiladas con bibliotecas E " "5.2.18 o bibliotecas a.out el límite es de 2 caracteres)." #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 #, fuzzy #| msgid "" #| "Note: For gettys or other login processes, the I field should be the " #| "tty suffix of the corresponding tty, e.g.\\& B<1> for B. " #| "Otherwise, the login accounting might not work correctly." msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" "Nota: Para gettys u otros procesos de presentación al sistema, el campo " "I debería de ser el sufijo tty de la correspondiente tty, por ejemplo, " "\\& B<1> para B. En otro caso, las contabilidades de conexiones puede " "que no funcionen correctamente." #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "" "es la lista de niveles de ejecución para lo cuales se llevarán a cabo las " "acciones especificadas." #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "describe qué acción se debería llevar a cabo." #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:70 #, fuzzy #| msgid "" #| "specifies the process to be executed. If the process field starts with a " #| "`+' character, B will not do utmp and wtmp accounting for that " #| "process. This is needed for gettys that insist on doing their own utmp/" #| "wtmp housekeeping. This is also a historic bug." msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" "especifica el proceso a ejecutar. Si el campo proceso comienza con un " "carácter `+', B no registrará utmp y wtmp para ese proceso. Esto es " "necesario para gettys que insisten en hacer sus propias labores de utmp/" "wtmp. Esto es también un fallo histórico." #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" "El campo I tiene que contener múltiples caracteres para " "diferente niveles de ejecución. Por ejemplo, B<123> especifica que el " "proceso se debería iniciar en los niveles de ejecución 1, 2 y 3. Las " "entrada de I B pueden contener una B, " "B, o B. Las entradas de campos de I de B, " "B y B se ignoran." #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" "Cuando se cambia un nivel de ejecución, cualesquiera procesos en ejecución " "que no estén especificados en el nuevo nivel de ejecución se matan, primero " "con \\s-2SIGTERM\\s0 y después con \\s-2SIGKILL\\s0." #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "Acciones válidas para el campo I son:" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "El proceso se reiniciará cuando termine (v.g.\\& getty)." #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" "El proceso se iniciará una vez cuando se entre en el nivel de ejecución " "específico e B esperará a su terminación." #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "" "El proceso se ejecutará una vez cuando se entre en el nivel de ejecución " "especificado." #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" "El proceso se ejecutará durante el arranque del sistema. El campo The " "I se ignora." #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" "El proceso se ejecutará durante el arranque del sistema, mientras B " "espera su terminación (v.g.\\& /etc/rc). El campo I se " "ignora." #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "Esto no hace nada." #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" "Un proceso marcado con un nivel de ejecución B se ejecutará cuando " "se llame al nivel de ejecución especificado B. Sin embargo, no se " "produce cambio de nivel de ejecución (los niveles de ejecución B " "son `a', `b', y `c')." #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" "Una entrada B especifica el nivel de ejecución en el cual se " "entrará tras el arranque del sistema. Si no existe ninguno, B pedirá " "un nivel de ejecución en la consola. El campo I se ignora." #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" "El proceso se ejecutará durante el arranque del sistema. Se ejecutará antes " "de cualquier entrada B o B< bootwait>. El campo I " "se ignora." #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" "El proceso se ejecutará cuando B reciba la señal SIGPWR, indicando que " "hay algún problema con la alimentación eléctrica. B esperará que el " "proceso termine antes de continuar." #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" "Como en B, excepto que B no espera que el proceso se " "complete." #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 #, fuzzy msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" "El proceso se ejecutará cuando B reciba la señal SIGPWR, con la " "condición de que haya un fichero llamado B que contenga la " "palabra B. Esto significa que la alimentación eléctrica ha vuelto." #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" "Como en B, excepto que B no espera que el proceso se " "complete." #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" "El proceso se ejecutará cuando B reciba la señal B. Esto " "significa que alguien en la consola del sistema ha pulsado la combinación de " "teclas B . Normalmente uno quiere ejecutar algún tipo de " "B bien para entrar en modo monousuario o reiniciar la máquina." #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" "El proceso se ejecutará cuando B reciba una señal del gestor de " "teclado que se ha pulsado una combinación especial de teclas en el teclado " "de la consola." #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" "La documentación para esta función no está completa aun; se puede encontrar " "más documentación en los paquetes kbd-x.xx (el mas reciente era kbd-0.94 en " "el momento de escribir esto). Básicamente quiere aplicar alguna combinación " "de teclado a la acción \"KeyboardSignal\". Por ejemplo, para aplicar Alt-" "FlechaArriba para este propósito use lo siguiente en su fichero keymap:" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "alt keycode 103 = KeyboardSignal" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "" "Esto es un ejemplo de un inittab que reensambla el viejo inittab de Linux:" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" "# inittab para linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" #. type: Plain text #: ../inittab.5:222 msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" "Este fichero inittab ejecuta I durante el arranque e inicia gettys " "en tty1-tty4." #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" "Un B más elaborado con diferentes niveles de ejecución (vea los " "comentarios interiores):" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" "# Nivel para ejecutar\n" "id:2:initdefault:\n" #. type: Plain text #: ../inittab.5:234 #, fuzzy, no-wrap #| msgid "" #| "# System initialization before anything else.\n" #| "si::sysinit:/etc/rc.d/bcheckrc\n" msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" "# Inicialización del sistema antes de cualquier otra cosa.\n" "si::sysinit:/etc/rc.d/bcheckrc\n" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" "# Qué hacer ante el \"saludo de 3 dedos\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" #. type: Plain text #: ../inittab.5:265 #, fuzzy, no-wrap #| msgid "" #| "# Runlevel 2&3: getty on console, level 3 also getty on modem port.\n" #| "1:23:respawn:/sbin/getty tty1 VC linux\n" #| "2:23:respawn:/sbin/getty tty2 VC linux\n" #| "3:23:respawn:/sbin/getty tty3 VC linux\n" #| "4:23:respawn:/sbin/getty tty4 VC linux\n" #| "S2:3:respawn:/sbin/uugetty ttyS2 M19200\n" msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" "# Nivel de ejecución 2&3: getty en consola, nivel 3 también getty \n" "# en el puerto del módem.\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S2:3:respawn:/sbin/uugetty ttyS2 M19200\n" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "B fue escrito por E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> Esta página de manual fue escrita por E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> y " "modificada por E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "KILLALL5" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "4 de Noviembre de 2003" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "killall5 - envía una señal a todos los procesos" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" #. type: Plain text #: ../killall5.8:34 #, fuzzy #| msgid "" #| "B is the SystemV killall command. It sends a signal to all " #| "processes except the processes in its own session, so it won't kill the " #| "shell that is running the script it was called from. Its primary (only) " #| "use is in the B scripts found in the /etc/init.d directory." msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" "B es la orden killall de SystemV. Envía una señal a todos los " "procesos excepto al de su propia sesión, para no eliminar el shell que " "ejecutó el guión desde el que fue llamado. Su uso principal (único) es en el " "guión B que se encuentra en el directorio /etc/init.d" #. type: IP #: ../killall5.8:35 #, fuzzy, no-wrap #| msgid "-o I" msgid "B<-o> I" msgstr "-o I" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "" #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "B(8), B(8), B(8)" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "LAST," #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "1" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "31 de julio de 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "last, lastb - muestra los usuarios que han accedido al sistema" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" #. type: Plain text #: ../last.1:56 #, fuzzy #| msgid "" #| "B searches back through the I file (or the file " #| "designated by the B<-f> option) and displays a list of all users logged " #| "in (and out) since that file was created. One or more I and/" #| "or I can be given, in which case B will show only the entries " #| "matching those arguments. Names of I can be abbreviated, thus " #| "B is the same as B." msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" "B analiza el contenido del archivo I (o el que se haya " "indicada mediante la opción B<-f>) y muestra un listado con los usuarios " "conectados (y desconectados) desde la creación de dicho archivo. Es posible " "indicar uno o más I y/o I, en cuyo caso solo se " "mostrarán las entradas que coincidan con éstos patrones. También cabe la " "posibilidad de abreviar los nombres de los I, por ejemplo B es " "lo mismo que B." #. type: Plain text #: ../last.1:61 #, fuzzy #| msgid "" #| "When catching a SIGINT signal (generated by the interrupt key, usually " #| "control-C) or a SIGQUIT signal, B will show how far it has searched " #| "through the file; in the case of the SIGINT signal B will then " #| "terminate." msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" "Si B recibe una señal SIGINT (creada por una solicitud de " "interrupción, generalmente con Control-C) o SIGQUIT; se mostrará en qué " "punto estaba el análisis. En el caso de haber recibido la señal SIGINT, el " "proceso finalizará." #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "" "El pseudo-usuario B accede al sistema cada vez que se reinicia el " "equipo, por lo tanto B mostrará una lista de todos los " "reinicios desde la creación del archivo." #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" "B es idéntico a B salvo que analiza por defecto el archivo I que muestra los intentos de acceso fallidos." #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "B<-f> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" #. type: IP #: ../last.1:73 #, no-wrap msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 #, fuzzy #| msgid "Tell B how many lines to show." msgid "This is a count telling B how many lines to show." msgstr "Indica a B el número de líneas que debe mostrar." #. type: IP #: ../last.1:75 #, no-wrap msgid "B<-n> I" msgstr "B<-n> I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "" #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "" #. type: Plain text #: ../last.1:82 #, fuzzy #| msgid "" #| "Display the state of logins since the specified I," #~ msgstr "B," #~ msgid "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgstr "Miquel van Smoorenburg, miquels@cistron.nl" #, no-wrap #~ msgid "fstab-decode" #~ msgstr "fstab-decode" #~ msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #, fuzzy, no-wrap #~| msgid "LAST, LASTB" #~ msgid "LAST,LASTB" #~ msgstr "LAST, LASTB" #, fuzzy, no-wrap #~| msgid "Linux System Administrator's Manual" #~ msgid "Linux User's Manual" #~ msgstr "Manual del Administrador del Sistema Linux" #, fuzzy #~| msgid "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgid "Miquel van Smoorenburg (miquels@cistron.nl)" #~ msgstr "Miquel van Smoorenburg, miquels@cistron.nl" #, no-wrap #~ msgid "-s" #~ msgstr "-s" #, no-wrap #~ msgid "-c" #~ msgstr "-c" #, no-wrap #~ msgid "-n" #~ msgstr "-n" #, no-wrap #~ msgid "-q" #~ msgstr "-q" #, no-wrap #~ msgid "-x" #~ msgstr "-x" #, no-wrap #~ msgid "-z" #~ msgstr "-z" #, fuzzy #~| msgid "" #~| "B looks for the environment variable B or B " #~| "to determine what shell to start. If the environment variable is not " #~| "set, it will try to execute root's shell from I. If that " #~| "fails, it will fall back to I." #~ msgid "" #~ "I looks for the environment variable B or B to " #~ "determine what shell to start. If the environment variable is not set, it " #~ "will try to execute root's shell from /etc/passwd. If that fails it will " #~ "fall back to B." #~ msgstr "" #~ "B busca la variable de entorno B o B para " #~ "saber que entorno debe comenzar. Si la variable de entorno no está " #~ "puesta, probará a ejecutar el entorno del root desde I. Si " #~ "falla retrocederá a I." #, fuzzy #~| msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgid "Miquel van Smoorenburg Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #, no-wrap #~ msgid "systemd 249" #~ msgstr "systemd 249" #, no-wrap #~ msgid "halt" #~ msgstr "halt" #~ msgid "B [OPTIONS...]" #~ msgstr "B [OPCIONES...]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [OPCIONES...]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [OPCIONES...]" #~ msgid "B<--help>" #~ msgstr "B<--help>" #~ msgid "Print a short help text and exit\\&." #~ msgstr "Mostrar texto de ayuda y finalizar\\&." #~ msgid "B<--halt>" #~ msgstr "B<--halt>" #~ msgid "B<-p>, B<--poweroff>" #~ msgstr "B<-p>, B<--poweroff>" #~ msgid "B<--reboot>" #~ msgstr "B<--reboot>" #~ msgid "B<-f>, B<--force>" #~ msgstr "B<-f>, B<--force>" #~ msgid "B<-w>, B<--wtmp-only>" #~ msgstr "B<-w>, B<--wtmp-only>" #~ msgid "B<-d>, B<--no-wtmp>" #~ msgstr "B<-d>, B<--no-wtmp>" #~ msgid "B<-n>, B<--no-sync>" #~ msgstr "B<-n>, B<--no-sync>" #~ msgid "B<--no-wall>" #~ msgstr "B<--no-wall>" #~ msgid "On success, 0 is returned, a non-zero failure code otherwise\\&." #~ msgstr "" #~ "En caso de éxito se devuelve 0, en caso contrario un código de fallo " #~ "diferente de cero\\&." #~ msgid "B(1), B(1), B(8), B(1)" #~ msgstr "B(1), B(1), B(8), B(1)" #, fuzzy, no-wrap #~ msgid "systemd 250" #~ msgstr "systemd 249" #, no-wrap #~ msgid "2021-06-02" #~ msgstr "2 Junio 2021" #, no-wrap #~ msgid "util-linux 2.37.2" #~ msgstr "util-linux 2.37.2" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [opciones] [I...] [I...]" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [opciones] [I...] [I...]" #~ msgid "" #~ "B searches back through the I file (or the file " #~ "designated by the B<-f> option) and displays a list of all users logged " #~ "in (and out) since that file was created. One or more I and/or " #~ "I can be given, in which case B will show only the entries " #~ "matching those arguments. Names of I can be abbreviated, thus " #~ "B is the same as B." #~ msgstr "" #~ "B analiza el contenido del archivo I (o el que se " #~ "haya indicada mediante la opción B<-f>) y muestra un listado con los " #~ "usuarios conectados (y desconectados) desde la creación de dicho archivo. " #~ "Es posible indicar uno o más I y/o I, en cuyo " #~ "caso solo se mostrarán las entradas que coincidan con éstos patrones. " #~ "También cabe la posibilidad de abreviar los nombres de los I, por " #~ "ejemplo B es lo mismo que B." #~ msgid "" #~ "When catching a B signal (generated by the interrupt key, usually " #~ "control-C) or a SIGQUIT signal, B will show how far it has searched " #~ "through the file; in the case of the B signal B will then " #~ "terminate." #~ msgstr "" #~ "Si B recibe una señal B (creada por una solicitud de " #~ "interrupción, generalmente con Control-C) o SIGQUIT; se mostrará en qué " #~ "punto estaba el análisis. En el caso de haber recibido la señal " #~ "B, el proceso finalizará." #~ msgid "" #~ "The pseudo user B logs in each time the system is rebooted. Thus " #~ "B will show a log of all the reboots since the log file was " #~ "created." #~ msgstr "" #~ "El pseudo-usuario B accede al sistema cada vez que se reinicia el " #~ "equipo, por lo tanto B mostrará una lista de todos los " #~ "reinicios desde la creación del archivo." #~ msgid "B<-a>, B<--hostlast>" #~ msgstr "B<-a>,B< --hostlast>" #~ msgid "B<-d>, B<--dns>" #~ msgstr "B<-d>,B< --dns>" #~ msgid "" #~ "Tell B to use a specific I instead of I. The " #~ "B<--file> option can be given multiple times, and all of the specified " #~ "files will be processed." #~ msgstr "" #~ "Indica a B que debe usar el I indicado en lugar de I. Es posible indicar varios archivos usando varias veces la " #~ "opción B<--file>, procesándose así todos los archivos indicados." #~ msgid "B<-F>, B<--fulltimes>" #~ msgstr "B<-F>,B< --fulltimes>" #~ msgid "B<-i>, B<--ip>" #~ msgstr "B<-i>,B< --ip>" #~ msgid "" #~ "Like B<--dns ,> but displays the host\\(cqs IP number instead of the name." #~ msgstr "" #~ "Igual que B<--dns>, pero muestra la dirección IP del equipo en lugar de " #~ "su nombre." #~ msgid "B<->I; B<-n>, B<--limit> I" #~ msgstr "B<->I; B<-n>, B<--limit> I" #~ msgid "B<-p>, B<--present> I, B, B" msgstr "" #. type: Plain text #: ../init.8:175 msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "B tai B" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "" #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "B tai B" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "" #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "B tai B" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "YMPÄRISTÖ" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "I" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "" #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "" #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "B<-s, S, single>" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "B<1-5>" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "" #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "B<-b, emergency>" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "B<-a, auto>" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "B<-z >I" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "" #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "TIEDOSTOT" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "INITCTL" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "13. huhtikuuta 2018" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "/run/initctl" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "" #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "/run/initctl /sbin/init" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "INITSCRIPT" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "10. heinäkuuta 2003" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" #. type: Plain text #: ../initscript.5:65 msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "/etc/inittab, /etc/initscript." #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "B(5), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "4. joulukuuta 2001" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "" #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "" #. type: Plain text #: ../inittab.5:48 msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "" #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "" #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "" #. type: Plain text #: ../inittab.5:70 msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "" #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "" #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "" #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" #. type: Plain text #: ../inittab.5:222 msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" #. type: Plain text #: ../inittab.5:234 #, no-wrap msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" #. type: Plain text #: ../inittab.5:265 #, no-wrap msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "KILLALL5" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "4. marraskuuta 2003" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" #. type: IP #: ../killall5.8:35 #, fuzzy, no-wrap #| msgid "B<-f>, B<--file> I" msgid "B<-o> I" msgstr "B<-f>, B<--file> I" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "" #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "B(8), B(8), B(8)" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "LAST," #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "1" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "31. heinäkuuta 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" #. type: Plain text #: ../last.1:56 msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" #. type: Plain text #: ../last.1:61 msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "B<-f> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" #. type: IP #: ../last.1:73 #, fuzzy, no-wrap #| msgid "B<->I" msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 msgid "This is a count telling B how many lines to show." msgstr "" #. type: IP #: ../last.1:75 #, fuzzy, no-wrap #| msgid "B<->I" msgid "B<-n> I" msgstr "B<->I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "" #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "" #. type: Plain text #: ../last.1:82 msgid "" "Display the state of logins as of the specified time. This is useful, e.g., " "to determine easily who was logged in at a particular time -- specify that " "time with B<-t> and look for \"still logged in\"." msgstr "" #. type: IP #: ../last.1:82 #, no-wrap msgid "B<-R>" msgstr "B<-R>" #. type: Plain text #: ../last.1:84 msgid "Suppresses the display of the hostname field." msgstr "" #. {{{ -a #. type: IP #: ../last.1:84 ../logsave.8:40 ../shutdown.8:56 #, no-wrap msgid "B<-a>" msgstr "B<-a>" #. type: Plain text #: ../last.1:87 msgid "" "Display the hostname in the last column. Useful in combination with the next " "flag." msgstr "" #. type: Plain text #: ../last.1:91 msgid "" "For non-local logins, Linux stores not only the host name of the remote host " "but its IP number as well. This option translates the IP number back into a " "hostname." msgstr "" #. type: IP #: ../last.1:91 ../shutdown.8:91 #, no-wrap msgid "B<-F>" msgstr "B<-F>" #. type: Plain text #: ../last.1:93 msgid "Print full login and logout times and dates." msgstr "" #. type: Plain text #: ../last.1:96 msgid "" "This option is like B<-d> in that it displays the IP number of the remote " "host, but it displays the IP number in numbers-and-dots notation." msgstr "" #. type: IP #: ../last.1:96 #, no-wrap msgid "B<-l>" msgstr "B<-l>" #. type: Plain text #: ../last.1:100 msgid "" "This option allows the display of usernames longer than 8 characters. This " "may mess up formatting in some programs and make the output wider than the " "standard 80 characters." msgstr "" #. type: IP #: ../last.1:100 ../utmpdump.1:33 #, no-wrap msgid "B<-o>" msgstr "B<-o>" #. type: Plain text #: ../last.1:102 msgid "Read an old-type wtmp file (written by linux-libc5 applications)." msgstr "" #. type: Plain text #: ../last.1:104 msgid "Display full user and domain names in the output." msgstr "" #. type: IP #: ../last.1:104 ../mountpoint.1:40 ../pidof.8:63 #, no-wrap msgid "B<-x>" msgstr "B<-x>" #. }}} #. type: Plain text #: ../last.1:107 msgid "Display the system shutdown entries and run level changes." msgstr "" #. {{{ Files #. type: Plain text #: ../last.1:114 msgid "" "The files I and I might not be found. The system only logs " "information in these files if they are present. This is a local " "configuration issue. If you want the files to be used, they can be created " "with a simple B(1) command (for example, B)." msgstr "" #. type: Plain text #: ../last.1:116 msgid "/var/log/wtmp" msgstr "/var/log/wtmp" #. }}} #. {{{ Author #. type: Plain text #: ../last.1:120 msgid "/var/log/btmp" msgstr "/var/log/btmp" #. type: Plain text #: ../last.1:129 msgid "B(8), B(1), B(8)" msgstr "B(8), B(1), B(8)" #. type: TH #: ../logsave.8:5 #, no-wrap msgid "LOGSAVE" msgstr "LOGSAVE" #. type: Plain text #: ../logsave.8:8 msgid "logsave - save the output of a command in a logfile" msgstr "" #. type: Plain text #: ../logsave.8:14 msgid "B [ B<-asv> ] I" msgstr "" #. type: Plain text #: ../logsave.8:27 msgid "" "The B program will execute I with the specified " "argument(s), and save a copy of its output to I. If the containing " "directory for I does not exist, B will accumulate the " "output in memory until it can be written out. A copy of the output will " "also be written to standard output." msgstr "" #. type: Plain text #: ../logsave.8:34 msgid "" "If I is a single hyphen ('-'), then instead of executing a " "program, B will take its input from standard input and save it in " "I." msgstr "" #. type: Plain text #: ../logsave.8:39 msgid "" "B is useful for saving the output of initial boot scripts until the " "I partition is mounted, so the output can be written to I." msgstr "" #. type: Plain text #: ../logsave.8:45 msgid "" "This option will cause the output to be appended to I, instead of " "replacing its current contents." msgstr "" #. type: Plain text #: ../logsave.8:53 msgid "" "This option will cause B to skip writing to the log file text which " "is bracketed with a control-A (ASCII 001 or Start of Header) and control-B " "(ASCII 002 or Start of Text). This allows progress bar information to be " "visible to the user on the console, while not being written to the log file." msgstr "" #. type: Plain text #: ../logsave.8:58 msgid "" "This option will make B to be more verbose in its output to the " "user." msgstr "" #. type: Plain text #: ../logsave.8:62 msgid "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" msgstr "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" #. type: Plain text #: ../logsave.8:63 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "MESG" msgstr "MESG" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "Feb 26, 2001" msgstr "26. helmikuuta 2001" #. type: TH #: ../mesg.1:20 ../mountpoint.1:18 ../readbootlog.1:20 ../utmpdump.1:18 #: ../wall.1:18 #, no-wrap msgid "User Commands" msgstr "Käyttäjän sovellukset" #. }}} #. {{{ Synopsis #. type: Plain text #: ../mesg.1:27 msgid "mesg - control write access to your terminal" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../mesg.1:32 msgid "B [B|B]" msgstr "B [B|B]" #. }}} #. {{{ Options #. type: Plain text #: ../mesg.1:38 msgid "" "B controls the access to your terminal by others. It's typically used " "to allow or disallow other users to write to your terminal (see B(1))." msgstr "" #. type: IP #: ../mesg.1:39 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:41 msgid "Allow write access to your terminal." msgstr "" #. type: IP #: ../mesg.1:41 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:43 msgid "Disallow write access to your terminal." msgstr "" #. }}} #. {{{ Notes #. type: Plain text #: ../mesg.1:48 #, fuzzy #| msgid "" #| "If no arguments are given, B shows the current message status on " #| "standard error output." msgid "" "If no option is given, B prints out the current access state of your " "terminal." msgstr "" "Jos mitään vakiota ei annetta, B tulostaa ruutusi tämänhetkisen oikeus " "tason." #. type: Plain text #: ../mesg.1:53 msgid "" "B assumes that its standard input is connected to your terminal. That " "also means that if you are logged in multiple times, you can get/set the " "mesg status of other sessions by using redirection. For example \"mesg n " "E /dev/pts/46\"." msgstr "" #. type: Plain text #: ../mesg.1:62 msgid "B(1), B(1), B(1)" msgstr "B(1), B(1), B(1)" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "MOUNTPOINT" msgstr "MOUNTPOINT" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "Mar 15, 2004" msgstr "15. maaliskuuta 2004" #. type: Plain text #: ../mountpoint.1:21 msgid "mountpoint - see if a directory is a mountpoint" msgstr "" #. type: Plain text #: ../mountpoint.1:26 msgid "B [B<-q>] [B<-d>] I" msgstr "" #. type: Plain text #: ../mountpoint.1:30 msgid "B B<-x> I" msgstr "" #. type: Plain text #: ../mountpoint.1:32 msgid "B checks if the directory is a mountpoint." msgstr "" #. type: IP #: ../mountpoint.1:34 ../pidof.8:60 ../shutdown.8:107 #, no-wrap msgid "B<-q>" msgstr "B<-q>" #. type: Plain text #: ../mountpoint.1:36 msgid "Be quiet - don't print anything." msgstr "" #. type: Plain text #: ../mountpoint.1:38 msgid "Print major/minor device number of the filesystem on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:40 msgid "" "Check Linux's I file to try to detect circular mount points." msgstr "" #. type: Plain text #: ../mountpoint.1:42 msgid "Print major/minor device number of the blockdevice on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:44 msgid "Zero if the directory is a mountpoint, non-zero if not." msgstr "" #. type: Plain text #: ../mountpoint.1:48 msgid "" "Symbolic links are not followed, except when the B<-x> option is used. To " "force following symlinks, add a trailing slash to the path of the directory." msgstr "" #. type: Plain text #: ../mountpoint.1:52 msgid "" "The name of the command is misleading when the B<-x> option is used, but the " "option is useful for comparing if a directory and a device match up, and " "there is no other command that can print the info easily." msgstr "" #. type: Plain text #: ../mountpoint.1:57 msgid "" "The mountpoint command fails when a directory is binded to one of its " "grandparents. For example, if /a/b/c/d is a mount point for /a/b then " "mountpoint will report /a/b/c/d is not a valid mount point. This is because " "both the original directory and its new mount point share the same inode and " "device number." msgstr "" #. type: Plain text #: ../mountpoint.1:66 msgid "" "The circular mount problem can be worked around on Linux systems by using " "theB<-p> flag to check the I file for references to the " "circular mount bind. When using the B<-p> flag, make sure to specify the " "full path (ie I and not just I). Also, B may " "still fail if there are spaces in the mount point's path, even when using " "the B<-p> flag because of the way B mangles the spaces in the " "path name. Of course, if the admin is using circular mount points with " "spaces in the name, there are bigger concerns." msgstr "" #. type: Plain text #: ../mountpoint.1:71 msgid "B(1)" msgstr "B(1)" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "PIDOF" msgstr "PIDOF" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "01 Sep 1998" msgstr "1. syyskuuta 1998" #. type: Plain text #: ../pidof.8:21 msgid "pidof - find the process ID of a running program" msgstr "" #. type: Plain text #: ../pidof.8:36 msgid "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> I] [B<-o> I] [B<-d> I] I " "[I]" msgstr "" #. type: Plain text #: ../pidof.8:44 msgid "" "B finds the process id's (PIDs) of the named programs. It prints " "those id's on the standard output. This program is on some systems used in " "run-level change scripts, especially when the system has a I like " "I structure. In that case these scripts are located in I, " "where ? is the runlevel. If the system has a B(8) program " "that should be used instead." msgstr "" #. type: Plain text #: ../pidof.8:47 msgid "Single shot - this instructs the program to only return one I." msgstr "" #. type: Plain text #: ../pidof.8:51 msgid "" "Only return process PIDs that are running with the same root directory. " "This option is ignored for non-root users, as they will be unable to check " "the current root directory of processes they do not own." msgstr "" #. type: Plain text #: ../pidof.8:60 msgid "" "Avoid B(2) system function call on all binaries which are located on " "network based file systems like B. Instead of using this option the " "variable B may be set and exported." msgstr "" #. type: Plain text #: ../pidof.8:63 msgid "" "Do not display matched PIDs to standard out. Simply exit with a status of " "true or false to indicate whether a matching PID was found." msgstr "" #. type: Plain text #: ../pidof.8:66 msgid "" "Scripts too - this causes the program to also return process id's of shells " "running the named scripts." msgstr "" #. type: IP #: ../pidof.8:66 #, no-wrap msgid "B<-z>" msgstr "B<-z>" #. type: Plain text #: ../pidof.8:73 msgid "" "Try to detect processes which are stuck in zombie (Z) status. Usually these " "processes are skipped as trying to deal with them can cause pidof or related " "tools to hang. Note: In the past pidof would ignore processes in the " "uninterruptable state (D), unless the B<-z> flag was specified. This is no " "longer the case. The B program will find and report processes in the " "D state whether B<-z> is specified or not." msgstr "" #. type: IP #: ../pidof.8:73 #, no-wrap msgid "-d I" msgstr "" #. type: Plain text #: ../pidof.8:76 msgid "" "Tells I to use I as an output separator if more than one PID is " "shown. The default separator is a space." msgstr "" #. type: IP #: ../pidof.8:76 #, no-wrap msgid "-o I" msgstr "" #. type: Plain text #: ../pidof.8:80 msgid "" "Tells I to omit processes with that process id. The special pid B<" "%PPID> can be used to name the parent process of the B program, in " "other words the calling shell or shell script." msgstr "" #. type: TP #: ../pidof.8:81 #, no-wrap msgid "B<0>" msgstr "B<0>" #. type: Plain text #: ../pidof.8:84 msgid "At least one program was found with the requested name." msgstr "" #. type: TP #: ../pidof.8:84 #, no-wrap msgid "B<1>" msgstr "B<1>" #. type: Plain text #: ../pidof.8:87 msgid "No program was found with the requested name." msgstr "" #. type: Plain text #: ../pidof.8:90 msgid "" "I is actually the same program as B(8); the program behaves " "according to the name under which it is called." msgstr "" #. type: Plain text #: ../pidof.8:98 msgid "" "When B is invoked with a full pathname to the program it should find " "the pid of, it is reasonably safe. Otherwise it is possible that it returns " "PIDs of running programs that happen to have the same name as the program " "you're after but are actually other programs. Note that the executable name " "of running processes is calculated with B(2), so symbolic links to " "executables will also match." msgstr "" #. type: Plain text #: ../pidof.8:103 msgid "" "Zombie processes or processes in disk sleep (states Z and D, respectively) " "are ignored, as attempts to access the stats of these will sometimes fail. " "The B<-z> flag (see above) tells B to try to detect these sleeping " "and zombie processes, at the risk of failing or hanging." msgstr "" #. type: Plain text #: ../pidof.8:110 msgid "B(8), B(8), B(8), B(8), B(8)" msgstr "B(8), B(8), B(8), B(8), B(8)" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "READBOOTLOG" msgstr "READBOOTLOG" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "NOV 12, 2018" msgstr "12. marraskuuta 2018" #. }}} #. {{{ Synopsis #. type: Plain text #: ../readbootlog.1:27 msgid "" "readbootlog - show contents of the boot log, stripping away control " "characters" msgstr "" #. type: Plain text #: ../readbootlog.1:31 msgid "B [B<-h>] [-B I]" msgstr "B [B<-h>] [-B I]" #. }}} #. {{{ Options #. type: Plain text #: ../readbootlog.1:42 msgid "" "B is a tool for reading the boot log (by default I). The program strips away control characters and non-human readable " "contents from the log file. Output is dumped to the terminal where it can be " "piped or redirected to a file." msgstr "" #. type: Plain text #: ../readbootlog.1:45 msgid "" "Tells B to use a specific file instead of I." msgstr "" #. {{{ Files #. type: Plain text #: ../readbootlog.1:48 msgid "Displays a brief help message." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../readbootlog.1:52 msgid "/var/log/boot" msgstr "/var/log/boot" #. }}} #. {{{ See also #. type: Plain text #: ../readbootlog.1:58 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" #. type: Plain text #: ../readbootlog.1:59 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "RUNLEVEL" msgstr "RUNLEVEL" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "May 27, 1997" msgstr "27. toukokuuta 1997" #. type: Plain text #: ../runlevel.8:21 msgid "runlevel - find the previous and current system runlevel" msgstr "" #. type: Plain text #: ../runlevel.8:24 msgid "B [I]" msgstr "" #. type: Plain text #: ../runlevel.8:34 msgid "" "B reads the system I file (typically I) to " "locate the runlevel record, and then prints the previous and current system " "runlevel on its standard output, separated by a single space. If there is no " "previous system runlevel, the letter B will be printed instead." msgstr "" #. type: Plain text #: ../runlevel.8:42 msgid "" "If no I file exists, and if no runlevel record can be found in the I file, B prints the word B and exits " "with an error." msgstr "" #. type: Plain text #: ../runlevel.8:49 msgid "" "B can be used in I scripts as a substitute for the System-V " "B command. However, in newer versions of B(8) this " "information is also available in the environment variables B and " "B." msgstr "" #. {{{ utmp #. type: IP #: ../runlevel.8:51 #, no-wrap msgid "I" msgstr "" #. }}} #. type: Plain text #: ../runlevel.8:54 msgid "The name of the I file to read." msgstr "" #. type: Plain text #: ../runlevel.8:57 msgid "B(8), B(5)" msgstr "B(8), B(5)" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "SHUTDOWN" msgstr "SHUTDOWN" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "November 12, 2003" msgstr "12. marraskuuta 2003" #. }}} #. {{{ Synopsis #. type: Plain text #: ../shutdown.8:27 msgid "shutdown - bring the system down" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../shutdown.8:36 msgid "" "B [B<-akrhPHfFncqQ>] [B<-t> I] I," #~ msgstr "B," #, fuzzy, no-wrap #~| msgid "LAST, LASTB" #~ msgid "LAST,LASTB" #~ msgstr "LAST, LASTB" #, no-wrap #~ msgid "2021-06-02" #~ msgstr "2. kesäkuuta 2021" #, no-wrap #~ msgid "util-linux 2.37.2" #~ msgstr "util-linux 2.37.2" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [valitsin] [I...] [I...]" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [valitsin] [I...] [I...]" #~ msgid "B<-a>, B<--hostlast>" #~ msgstr "B<-a>, B<--hostlast>" #~ msgid "B<-d>, B<--dns>" #~ msgstr "B<-d>, B<--dns>" #~ msgid "B<-F>, B<--fulltimes>" #~ msgstr "B<-F>, B<--fulltimes>" #~ msgid "B<-i>, B<--ip>" #~ msgstr "B<-i>, B<--ip>" #~ msgid "B<-p>, B<--present> I,B,B" msgid "B, B, B" msgstr "B,B,B" #. type: Plain text #: ../init.8:175 #, fuzzy #| msgid "" #| "tell B to process only those B file entries having " #| "runlevel B,B or B." msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" "Demander à B de ne traiter que les entrées du fichier I " "ayant le niveau d'exécution B, B ou B." #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "B ou B" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "Demander à B de réexaminer le fichier I." #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "B ou B" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "Demander à B de passer en mode mono-utilisateur" #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "B ou B" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" "Demander à B de se relancer lui-même (en préservant son état). Le " "fichier I n'est pas réexaminé. Le niveau d'exécution doit être " "un des niveaux B, sinon la requête est ignorée silencieusement." #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" "B peut indiquer à B combien de temps il devrait attendre " "entre l'envoi des signaux B et B aux processus. La valeur " "par défaut est de 3 secondes, mais elle peut être changée avec l'option B<-" "t>." #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" "B indique à B de changer l'environnement des processus " "qu'il lance. Le paramètre de B<-e> est soit de la forme I=I, qui " "positionne la variable I à la valeur I, ou de la forme I " "(sans signe égal), qui retire la variable I." #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" "B ne peut être appelé que par les utilisateurs avec les droits " "appropriés." #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" "Le binaire B vérifie s'il s'agit d'B ou de B en " "fonction de l'identifiant du processus ; le véritable B a toujours un " "identifiant égal à B<1>. Grâce à cela, B peut également être appelé au " "lieu de B, comme raccourci." #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "ENVIRONNEMENT" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "" "B configure les variables d'environnement suivantes pour tous ses " "enfants :" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "I" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" "Comme le nom l'indique. Utile pour déterminer si un script est exécuté " "directement par B." #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "Le niveau d'exécution actuel du système." #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "" "Le niveau d'exécution précédent (utile après un changement de niveau " "d'exécution)." #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" "La console système. Cela provient directement du noyau ; cependant si elle " "n'existe pas, B la positionne à I par défaut." #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "ATTRIBUTS D'AMORÇAGE" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" "Un certain nombre d'options peuvent être fournies à B à partir du " "gestionnaire de démarrage (par exemple LILO ou GRUB). B accepte les " "options suivantes :" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "B<-s>, B, B" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" "Démarrage en mode mono-utilisateur. Dans ce mode, I est " "examiné et les scripts rc de démarrage sont généralement lancés avant que " "l'interpréteur de commande du mono-utilisateur ne commence." #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "B<1>–B<5>" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "Niveau d'exécution dans lequel il faut démarrer." #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "B<-b>, B" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" "Démarrage direct d'un interpréteur de commande en mode mono-utilisateur sans " "lancer aucun autre script de démarrage." #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "B<-a>, B" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" "Le gestionnaire de démarrage LILO ajoute le mot « auto » sur la ligne de " "commande pour les démarrages utilisant la ligne de commande par défaut (sans " "intervention d'un utilisateur). Dans ce cas, B positionne la variable " "d'environnement B à la valeur « yes ». Notez que vous ne pouvez " "pas utiliser cela à des fins sécuritaires ; un utilisateur pouvant bien sûr " "indiquer « auto » ou ajouter l'option B<-a> lui-même sur la ligne de " "commande." #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "B<-z> I" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" "Le paramètre de B<-z> est ignoré. Vous pouvez utiliser cela pour étendre " "légèrement la ligne de commande pour qu'elle prenne plus de place sur la " "pile. B peut ensuite manipuler la ligne de commande de telle sorte que " "B(1) affiche le niveau d'exécution actuel." #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" "Cet argument, utilisé seul, affiche la version actuelle d’B sur la " "console/stdout. C’est un moyen rapide pour déterminer quel logiciel " "d’initialisation est en cours d’utilisation. Après l’affichage de la " "version, B se termine immédiatement avec zéro comme code de retour." #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "INTERFACE" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" "B écoute sur une I dans I, I, dans l'attente " "de messages. B utilise cela pour communiquer avec B. " "L'interface n'est pas très documentée ou finalisée. Les personnes " "intéressées devraient étudier le fichier I dans le sous-" "répertoire I de l'archive tar des sources d'B." #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "SIGNAUX" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "B réagit à plusieurs signaux :" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "Identique à B." #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" "Lors de la réception de ces signaux, B ferme et réouvre sa fifo de " "contrôle, I. Cela est utile pour les scripts de démarrage " "quand I est remonté." #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" "Quand B reçoit B, il ferme et abandonne la fifo de contrôle, " "I, fermée. Cela peut être utilisé pour être sûr que qu’B " "ne maintient pas ouvert un quelconque fichier. Toutefois, il empêche aussi " "B de changer les niveaux d’exécution, ce qui signifie que des " "commandes telles que B ne fonctionneront plus. La fifo peut être " "réouverte en envoyant à B le signal B." #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" "Normalement le noyau envoie ce signal à B à travers la combinaison de " "touches Ctrl-Alt-Suppr. Cela active l'action I." #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" "Le noyau envoie ce signal quand la touche I est pressée. " "Cela active l'action I." #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "CONFORMITÉ" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" "B est compatible avec l'init de Système V. Il collabore étroitement " "avec les scripts des répertoires I et I. Si votre système utilise cette convention, il " "devrait y avoir un fichier I dans le répertoire I qui " "explique comment ces scripts fonctionnent." #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "FICHIERS" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "AVERTISSEMENTS" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" "B suppose que les processus et leurs descendants restent dans le même " "groupe de processus créé initialement pour eux. Si les processus changent " "leur groupe, B ne peut pas les tuer et cela peut conduire à avoir deux " "processus qui lisent la même ligne de terminal." #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" "Sur un système Debian, entrer dans le niveau d'exécution B<1> force tous les " "processus à être tués à l'exception des threads du noyau et du script qui " "s'occupe de tuer les autres processus ainsi que les autres processus de sa " "session. En conséquence, il n'est pas sûr de passer du niveau " "d'exécution B<1> vers un niveau d'exécution multi-utilisateur : les démons " "qui étaient démarrés dans le niveau d'exécution B et qui sont nécessaires " "au bon fonctionnement ne tournent plus. Le système devrait être redémarré." #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" "Si B trouve qu'il n'arrête pas de relancer une entrée (plus de dix " "fois en deux minutes), il supposera qu'il y a une erreur dans la commande, " "générera une erreur sur la console système et refusera de relancer cette " "entrée à moins que cinq minutes se soient écoulées ou qu'il ait reçu un " "signal. Cela permet d'éviter de consommer des ressources système quand " "quelqu'un a fait une faute de frappe dans le fichier I ou que " "le programme de l'entrée a été supprimé." #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME> , page de " "manuel originelle de E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:." "de> Michael Haardt E<.ME .>" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "INITCTL" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "Formats de fichier" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "/run/initctl" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 #, fuzzy #| msgid "The previous runlevel (useful after a runlevel switch)." msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "" "Le niveau d'exécution précédent (utile après un changement de niveau " "d'exécution)." #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "/run/initctl /sbin/init" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "INITSCRIPT" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "10 juillet 2003" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "initscript - Script qui exécute les commandes incluses dans inittab" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "/bin/sh /etc/initscript id niveaux_exécution action processus" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" "Quand le script shell I est présent, B l'utilisera " "afin d'exécuter les commandes provenant d'I. Ce script peut être " "utilisé pour paramétrer des valeurs par défaut telles que I et " "I." #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" "Voici un exemple de script d'initialisation qui est peut-être installé sur " "votre système en tant que B." #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" "#\n" "# initscript exécuté par init(8) pour tout programme\n" "# voulant apparaître ainsi\\ :\n" "#\n" "# /bin/sh /etc/initscript EidE Eniveau d'exécutionE EactionE EprocessusE\n" "#\n" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" " # Paramétrer umask pour le mode sans échec,\n" " # et activer les core-dumps (sauvegardes d'image mémoire).\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" " # Augmenter la limite impérative des descripteurs de fichiers à 8192 pour tous les\n" " # processus. La limite souple est encore 1024, mais tous les\n" " # processus non privilégiés peuvent augmenter leur limite souple\n" " # jusqu'à la limite impérative\n" " # avec \"ulimit -Sn xxx\" (nécessite un noyau Linux 2.2.13 ou plus ).\n" " ulimit -Hn 8192\n" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" " # Exécuter le programme.\n" " eval exec \"$4\"\n" #. type: Plain text #: ../initscript.5:65 #, fuzzy #| msgid "" #| "This script is not meant as startup script for daemons or somesuch. It " #| "has nothing to do with a I style script. It's just a handler " #| "for things executed from B. Experimenting with this can " #| "make your system un(re)bootable." msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" "Ce script ne prétend pas être un script de démarrage pour les démons ou " "autres. Il n'a rien à voir avec les scripts du style I. C'est " "juste un gestionnaire pour ce qui est exécuté venant de B. " "Faire des expériences avec initscript peut rendre impossible le redémarrage " "de votre système." #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "/etc/inittab, /etc/initscript." #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "B(5), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "4 décembre 2001" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" "inittab - Format du fichier inittab utilisé dans le processus de démarrage " "des systèmes UNIX Système V et compatibles" #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" "Le fichier B décrit l'ensemble des processus qui doivent être " "lancés au démarrage du système et pendant un fonctionnement normal (par " "exemple, /etc/init.d/boot, /etc/init.d/rc, gettys…). Le programme B(8) " "distingue différents I (runlevel), chacun pouvant avoir " "ses propres processus à démarrer. Les niveaux d'exécution valables sont B<0>-" "B<6>, et B, B ou B pour des niveaux personnalisés (B). " "Typiquement, une entrée dans le fichier inittab a la forme suivante :" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "I:I:I:I" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "Les lignes commençant par le caractère « # » sont ignorées." #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:48 msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" "Séquence unique de 1 à 4 caractères qui identifient une entrée dans " "B (pour les versions de sysvinit compilées avec les I " "bibliothèques libc5 (E 5.2.18) ou a.out, la limite est de 2 caractères)." #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" "Remarque : pour les programmes de connexion comme les getty ou d'autres, le " "champ I doit être le numéro du tty correspondant à la console, par " "exemple B<1> pour B. Des anciens programmes de gestion des connexions " "peuvent également se baser là-dessus, même si je n'en ai pas le souvenir. " #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "Liste des niveaux d'exécution pour lesquels l'action doit être faite." #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "Description de l'action à faire." #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:70 msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" "Commande à exécuter. Si ce champ commence par le caractère « + », B " "n'enregistrera pas les connexions dans utmp et wtmp. C'est requis par getty " "qui utilise son propre gestionnaire de utmp ou de wtmp. C'est également un " "bogue qui reste pour des raisons historiques. La taille de ce champ est " "limitée à 127 caractères." #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" "Le champ I peut contenir plusieurs caractères indiquant " "différents niveaux d'exécution. Par exemple, B<123> signifie que le " "processus sera exécuté dans les niveaux d'exécution 1, 2 et 3. Les I pour les entrées B peuvent contenir un B, B ou " "B. Les champs I des entrées B, B et " "B sont ignorés." #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" "Quand le niveau d'exécution est changé, tous les processus qui ne sont pas " "spécifiés démarrés dans ce nouveau niveau d'exécution sont tués, d'abord " "avec \\s-2SIGTERM\\s0, puis avec \\s-2SIGKILL\\s0." #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "Les actions valables pour le champ I sont :" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "" "Le processus est redémarré à chaque fois qu'il se termine (par exemple : " "getty)." #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" "Le processus n'est démarré qu'une seul fois, lors de l'entrée dans le niveau " "d'exécution et B attend qu'il se termine." #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "" "Le processus est exécuté une seule fois, lors de l'entrée dans le niveau " "d'exécution." #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" "Le processus est exécuté pendant le démarrage du système. Le champ " "I est ignoré." #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" "Le processus est exécuté pendant le démarrage du système et B attend " "que le processus se termine (par exemple : /etc/rc). Le champ " "I est ignoré." #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "Ne fait rien." #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" "Un processus marqué dans un niveau d'exécution B est exécuté à " "chaque fois que le niveau d'exécution B est appelé. Cependant, " "aucun changement de niveau d'exécution ne survient (les modes de démarrage " "pour B sont « a », « b » et « c »)." #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" "Une entrée B indique qu'on entrera dans ce niveau d'exécution " "une fois le système effectivement opérationnel. Si aucun n'existe, B " "demandera un niveau d'exécution sur la console. Le champ I est " "ignoré." #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" "Le processus est exécuté pendant le démarrage du système. Il est exécuté " "avant les entrées B ou B. Le champ I est " "ignoré." #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" "Le processus est exécuté quand la machine est sur le point de s'éteindre. " "B est normalement informé de cela par un programme qui discute avec un " "UPS connecté à la machine. B attend que le processus se termine avant " "de continuer." #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" "Comme B, mis à part que B n'attend pas la fin du processus " "avant de continuer." #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" "Le processus est exécuté dès que B est informé que l'alimentation est " "remise en route." #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" "Ce processus est exécuté quand B est informé que la batterie de " "l'onduleur externe est presque vide et que la tension faiblit (à condition " "que l'onduleur et le processus de surveillance soient capables de détecter " "cette condition)." #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" "Le processus est exécuté lorsque B reçoit le signal B. Cela " "signifie que quelqu'un a tapé dans la console système la combinaison de " "touches B. Typiquement, on a voulu exécuter une sorte " "d'arrêt, soit pour démarrer en mode mono-utilisateur, soit pour redémarrer " "la machine." #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" "Le processus est exécuté quand B reçoit un signal du gestionnaire de " "clavier indiquant qu'une combinaison spéciale de touches a été actionnée sur " "le clavier de la console." #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" "La documentation pour cette fonction n'est pas encore complète ; il est " "possible de trouver de la documentation supplémentaire dans le paquet kbd-x." "xx paquets (le plus récent était kbd-0.94 au moment où ces lignes sont " "écrites). Vous pouvez affecter des combinaisons de touches à l'action " "« KeyboardSignal ». Par exemple, pour affecter Alt-FlècheHaut pour cet " "usage, utilisez ce qui suit dans votre fichier keymaps :" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "alt keycode 103 = KeyboardSignal" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "" "Voici un exemple d'un fichier inittab qui ressemble à un ancien fichier " "inittab sous linux :" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" "# inittab for Linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" #. type: Plain text #: ../inittab.5:222 msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" "Ce fichier inittab exécute I pendant le démarrage du système et " "démarre getty sur les tty 1 à 4." #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" "Un fichier B plus élaboré avec différents niveaux d'exécution " "(notez bien les commentaires) :" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" "# Runlevel à démarrer\n" "id:2:initdefault:\n" #. type: Plain text #: ../inittab.5:234 #, no-wrap msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" "# Script de configuration / initialisation du système au démarrage.\n" "si::sysinit:/etc/init.d/rcS\n" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" "# Que faire dans le mode mono-utilisateur.\n" "~:S:wait:/sbin/sulogin\n" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" "# /etc/init.d exécute les scripts S et K pour les changements\n" "# de niveau d'exécution.\n" "#\n" "# Le niveau 0 est pour l'arrêt.\n" "# Le niveau 1 est pour le mode mono-utilisateur.\n" "# Les niveaux 2 à 5 correspondent aux niveaux multi-utilisateurs.\n" "# Le niveau 6 correspond au redémarrage.\n" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" "# Que faire du « salut à 3 doigts ».\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" #. type: Plain text #: ../inittab.5:265 #, no-wrap msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" "# niveau d'exécution 2,3 : getty sur les consoles virtuelles\n" "# niveau d'exécution 3 : getty sur le terminal (ttyS0) et\n" "# sur le port modem.\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 #, fuzzy #| msgid "" #| "B was written by Miquel van Smoorenburg (miquels@cistron.nl). This " #| "manual page was written by Sebastian Lederer (lederer@francium.informatik." #| "uni-bonn.de) and modified by Michael Haardt (u31b3hs@pool.informatik.rwth-" #| "aachen.de)." msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "B a été écrit par Miquel van Smoorenburg (miquels@cistron.nl). Cette " "page de manuel a été écrite par Sebastian Lederer (lederer@francium." "informatik.uni-bonn.de) et modifiée par Michael Haardt (u31b3hs@pool." "informatik.rwth-aachen.de)." #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "KILLALL5" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "4 novembre 2003" # NOTE: Un seul tiret #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "killall5 - envoyer un signal à tous les processus" #. type: Plain text #: ../killall5.8:28 #, fuzzy #| msgid "B -signalnumber [B<-o> I] [B<-o> I]" msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "B -B [B<-o> I] [B<-o> I]" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" "B correspond à la commande B de Système V. Elle envoie un " "signal à tous les processus, sauf les threads du noyau et les processus de " "sa propre session. Il ne tuera donc pas l'interpréteur de commande qui l'a " "lancé. Son utilisation principale (unique) est dans les scripts B situés " "dans le répertoire I." #. type: IP #: ../killall5.8:35 #, no-wrap msgid "B<-o> I" msgstr "B<-o> I" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "Indiquer à B d'ignorer le processus avec cet identifiant." #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" "B peut aussi être appelé avec B(8), qui n'est qu'un lien " "(symbolique) pour le programme B." #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" "Le programme renvoie zéro s'il a tué les processus. Il renvoie B<2> si aucun " "processus n'a été tué et B<1> s'il n'a pas réussi à trouver de processus (I est absent)." #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "B(8), B(8), B(8)" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "LAST," #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "1" #. type: TH #: ../last.1:20 #, fuzzy, no-wrap #| msgid "Jul 21, 2003" msgid "Jul 31, 2004" msgstr "21 juillet 2003" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "last, lastb - afficher une liste des derniers utilisateurs connectés" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" #. type: Plain text #: ../last.1:56 #, fuzzy #| msgid "" #| "B searches back through the I file (or the file " #| "designated by the B<-f> option) and displays a list of all users logged " #| "in (and out) since that file was created. One or more I and/" #| "or I can be given, in which case B will show only the entries " #| "matching those arguments. Names of I can be abbreviated, thus " #| "B is the same as B." msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" "B parcourt le fichier I (ou le fichier indiqué par " "l'option B<-f>) pour présenter une liste de toutes les connexions et " "déconnexions des utilisateurs, depuis la création du fichier. Un ou " "plusieurs Is et terminaux (I) peuvent être indiqués, afin " "que B ne montre que les connexions et déconnexions correspondant à ces " "arguments. Le nom des terminaux peut être abrégé, ainsi I est " "équivalent à I." #. type: Plain text #: ../last.1:61 #, fuzzy #| msgid "" #| "When catching a SIGINT signal (generated by the interrupt key, usually " #| "control-C) or a SIGQUIT signal, B will show how far it has searched " #| "through the file; in the case of the SIGINT signal B will then " #| "terminate." msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" "À la réception d’un signal B (engendré par la touche d'interruption, " "généralement Contrôle-C) ou un signal B, B indiquera le point " "où il est arrivé dans le fichier, et dans le cas de B, B se " "terminera." #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "" "Le pseudo-utilisateur B est enregistré à chaque redémarrage du " "système, ainsi I affichera une liste de tous les redémarrages " "depuis la création du fichier de journalisation." #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" "B se comporte comme B, mais il utilise le fichier I qui journalise toutes les tentatives infructueuses de connexion." #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "B<-f> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" #. type: IP #: ../last.1:73 #, no-wrap msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 #, fuzzy #| msgid "Tell B how many lines to show." msgid "This is a count telling B how many lines to show." msgstr "Indiquer à B le nombre de lignes d'enregistrement à afficher." #. type: IP #: ../last.1:75 #, no-wrap msgid "B<-n> I" msgstr "B<-n> I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "" #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "" #. type: Plain text #: ../last.1:82 #, fuzzy #| msgid "" #| "Display the state of logins since the specified I," #~ msgstr "B," #~ msgid "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgstr "Miquel van Smoorenburg, miquels@cistron.nl" #, no-wrap #~ msgid "fstab-decode" #~ msgstr "fstab-decode" #~ msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg, Emiquels@cistron.nlE" #, fuzzy, no-wrap #~| msgid "Linux System Administrator's Manual" #~ msgid "Linux User's Manual" #~ msgstr "Manuel de l’Administrateur de Système Linux" #, fuzzy #~| msgid "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgid "Miquel van Smoorenburg (miquels@cistron.nl)" #~ msgstr "Miquel van Smoorenburg, miquels@cistron.nl" #, no-wrap #~ msgid "-s" #~ msgstr "B<-s>" #, no-wrap #~ msgid "-c" #~ msgstr "B<-c>" #, no-wrap #~ msgid "-n" #~ msgstr "B<-n>" #, no-wrap #~ msgid "-q" #~ msgstr "B<-q>" #, no-wrap #~ msgid "-x" #~ msgstr "B<-x>" #, no-wrap #~ msgid "-z" #~ msgstr "B<-z>" #, fuzzy #~| msgid "" #~| "B looks for the environment variable B or B " #~| "to determine what shell to start. If the environment variable is not " #~| "set, it will try to execute root's shell from I. If that " #~| "fails, it will fall back to I." #~ msgid "" #~ "I looks for the environment variable B or B to " #~ "determine what shell to start. If the environment variable is not set, it " #~ "will try to execute root's shell from /etc/passwd. If that fails it will " #~ "fall back to B." #~ msgstr "" #~ "B recherche les variables d’environnement B ou " #~ "B pour déterminer l’interpréteur de commandes à démarrer. Si la " #~ "variable d’environnement n’est pas définie, il essaiera d’exécuter " #~ "l’interpréteur de commandes du superutilisateur indiqué dans le fichier " #~ "I. Si cela échoue également, il essaiera I." #, fuzzy #~| msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgid "Miquel van Smoorenburg Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg, Emiquels@cistron.nlE" #~ msgid "" #~ "Try to detect processes which are stuck in uninterruptible (D) or zombie " #~ "(Z) status. Usually these processes are skipped as trying to deal with " #~ "them can cause pidof to hang." #~ msgstr "" #~ "Essayer de détecter les processus qui sont bloqués dans un état " #~ "ininterruptible (D) ou zombie (Z). Habituellement ces processus sont omis " #~ "car essayer de les traiter peut provoquer le plantage de B." #~ msgid "" #~ "In essence fstab-decode can be used anytime we want to pass multiple " #~ "parameters to a command as a list of command line arguments. It turns " #~ "output like this:" #~ msgstr "" #~ "En substance, fstab-decode peut être utilisé chaque fois que l'on veut " #~ "passer de multiples paramètres à une commande comme une liste de " #~ "paramètres en ligne de commande. Cela donne quelque chose comme ceci :" #~ msgid "" #~ "This script is not meant as startup script for daemons or somesuch. It " #~ "has nothing to do with a I style script. It's just a handler " #~ "for things executed from B. Experimenting with this can " #~ "make your system un(re)bootable." #~ msgstr "" #~ "Ce script ne prétend pas être un script de démarrage pour les démons ou " #~ "autres. Il n'a rien à voir avec les scripts du style I. C'est " #~ "juste un gestionnaire pour ce qui est exécuté venant de B. " #~ "Faire des expériences avec initscript peut rendre impossible le " #~ "redémarrage de votre système." #, no-wrap #~ msgid "2021-06-02" #~ msgstr "2 juin 2021" #, no-wrap #~ msgid "util-linux 2.37.2" #~ msgstr "util-linux 2.37.2" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [I] [I ...] [I ...]" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [I] [I ...] [I ...]" #, fuzzy #~| msgid "" #~| "B searches back through the I file (or the file " #~| "designated by the B<-f> option) and displays a list of all users logged " #~| "in (and out) since that file was created. One or more I and/" #~| "or I can be given, in which case B will show only the " #~| "entries matching those arguments. Names of I can be abbreviated, " #~| "thus B is the same as B." #~ msgid "" #~ "B searches back through the I file (or the file " #~ "designated by the B<-f> option) and displays a list of all users logged " #~ "in (and out) since that file was created. One or more I and/or " #~ "I can be given, in which case B will show only the entries " #~ "matching those arguments. Names of I can be abbreviated, thus " #~ "B is the same as B." #~ msgstr "" #~ "B parcourt le fichier I (ou le fichier indiqué par " #~ "l'option B<-f>) pour présenter une liste de toutes les connexions et " #~ "déconnexions des utilisateurs, depuis la création du fichier. Un ou " #~ "plusieurs Is et terminaux (I) peuvent être indiqués, " #~ "afin que B ne montre que les connexions et déconnexions " #~ "correspondant à ces arguments. Le nom des terminaux peut être abrégé, " #~ "ainsi I est équivalent à I." #, fuzzy #~| msgid "" #~| "When catching a SIGINT signal (generated by the interrupt key, usually " #~| "control-C) or a SIGQUIT signal, B will show how far it has " #~| "searched through the file; in the case of the SIGINT signal B will " #~| "then terminate." #~ msgid "" #~ "When catching a B signal (generated by the interrupt key, usually " #~ "control-C) or a SIGQUIT signal, B will show how far it has searched " #~ "through the file; in the case of the B signal B will then " #~ "terminate." #~ msgstr "" #~ "À la réception d’un signal B (engendré par la touche " #~ "d'interruption, généralement Contrôle-C) ou un signal B, B " #~ "indiquera le point où il est arrivé dans le fichier, et dans le cas de " #~ "B, B se terminera." #, fuzzy #~| msgid "" #~| "The pseudo user B logs in each time the system is rebooted. " #~| "Thus B will show a log of all the reboots since the log " #~| "file was created." #~ msgid "" #~ "The pseudo user B logs in each time the system is rebooted. Thus " #~ "B will show a log of all the reboots since the log file was " #~ "created." #~ msgstr "" #~ "Le pseudo-utilisateur B est enregistré à chaque redémarrage du " #~ "système, ainsi I affichera une liste de tous les " #~ "redémarrages depuis la création du fichier de journalisation." #, fuzzy #~| msgid "B<-a>,B< --hostlast>" #~ msgid "B<-a>, B<--hostlast>" #~ msgstr "B<-a>, B<--hostlast>" #, fuzzy #~| msgid "B<-d>,B< --dns>" #~ msgid "B<-d>, B<--dns>" #~ msgstr "B<-d>, B<--dns>" #, fuzzy #~| msgid "B<-f>,B< --file >I" #~ msgid "B<-f>, B<--file> I" #~ msgstr "B<-f>,B< --file >I" #, fuzzy #~| msgid "" #~| "Tell B to use a specific I instead of I. The " #~| "B<--file> option can be given multiple times, and all of the specified " #~| "files will be processed." #~ msgid "" #~ "Tell B to use a specific I instead of I. The " #~ "B<--file> option can be given multiple times, and all of the specified " #~ "files will be processed." #~ msgstr "" #~ "Indiquer à B d’utiliser le I indiqué au lieu de I. L’option B<--file> peut être indiquée plusieurs fois, et tous les " #~ "fichiers concernés seront traités." #, fuzzy #~| msgid "B<-F>,B< --fulltimes>" #~ msgid "B<-F>, B<--fulltimes>" #~ msgstr "B<-F>, B<--fulltimes>" #, fuzzy #~| msgid "B<-i>,B< --ip>" #~ msgid "B<-i>, B<--ip>" #~ msgstr "B<-i>, B<--ip>" #, fuzzy #~| msgid "" #~| "Like B<--dns ,> but displays the host's IP number instead of the name." #~ msgid "" #~ "Like B<--dns ,> but displays the host\\(cqs IP number instead of the name." #~ msgstr "" #~ "Comme B<--dns>, mais afficher l’adresse IP de l’hôte au lieu du nom." #, fuzzy #~| msgid "B<-n>,B< --limit >I" #~ msgid "B<->I; B<-n>, B<--limit> I" #~ msgstr "B<-n>, B<--limit> I" #, fuzzy #~| msgid "B<-p>,B< --present >I, B, B" msgstr "" #. type: Plain text #: ../init.8:175 msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "" #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "" #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "" #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "" #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "" #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" #. type: TP #: ../init.8:253 #, fuzzy, no-wrap #| msgid "B<-V>, B<--version>" msgid "B<--version>" msgstr "B<-V>, B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "" #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "FÁJLOK" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 #, fuzzy #| msgid "" #| "B was written by Miquel van Smoorenburg (miquels@cistron.nl). This " #| "manual page was written by Sebastian Lederer (lederer@francium.informatik." #| "uni-bonn.de) and modified by Michael Haardt (u31b3hs@pool.informatik.rwth-" #| "aachen.de)." msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "A B-et Miquel van Smoorenburg (miquels@cistron.nl) , a hozzávaló " "kézikönyvlapot pedig Sebastian Lederer (lederer@francium.informatik.uni-bonn." "de) írta és Michael Haardt (u31b3hs@pool.informatik.rwth-aachen.de) " "módosította." #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" #. type: TH #: ../initctl.5:17 #, fuzzy, no-wrap #| msgid "INITTAB" msgid "INITCTL" msgstr "INITTAB" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "" #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "" #. type: Plain text #: ../initctl.5:152 #, fuzzy #| msgid "B" msgid "B(8)" msgstr "B" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "" #. type: TH #: ../initscript.5:18 #, fuzzy, no-wrap #| msgid "July 2014" msgid "July 10, 2003" msgstr "2014 július" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" #. type: Plain text #: ../initscript.5:65 msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "" #. type: Plain text #: ../initscript.5:74 #, fuzzy #| msgid "B(8), B(8)" msgid "B(5), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" "inittab - a sysv-compatibilis init process által használt inittab fájl " "formátum." #. type: Plain text #: ../inittab.5:36 #, fuzzy #| msgid "" #| "The B file describes which processes are started at bootup and " #| "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " #| "gettys...). B(8) distinguishes multiple I, each of " #| "which can have its own set of processes that are started. Valid " #| "runlevels are B<0>-B<6> plus B, B, and B for B " #| "entries. An entry in the B file has the following format:" msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" "Az B fájl leírja mely processek indulnak el az induláskor és a " "normál műveletek közben (például:\\& /etc/rc, getty-k ...). Az B(8) " "megkülönböztet olyan többszörös I, ezek mindegyike saját " "beállítása lehet a futtantandó programokról. Érvényés futási szintek a B<0>-" "B<6>, ezenkívűl B, B, és B a B bejegyzésekhez. Egy " "inittab fájlbejegyzésnek a következő formátumúnak kell lennie:" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "I:I:I:I" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "A `#'-el kezdödő sorok mellőzésre kerülnek." #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:48 #, fuzzy #| msgid "" #| "is a unique sequence of 1-4 characters which identifies an entry in " #| "B (for versions of sysvinit compiled with libraries E 5.2.18 " #| "or a.out libraries the limit is 2 characters)." msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" "Egyedi, 1-4 elembol allo karakterlanc, ami azonosítja a bejegyzést az " "inittabban (azon sysvinit verziók esetében amelyek fordításához tartozó " "library E 5.2.18 , vagy még az a.out-os rendszerhez készűlt, a korlát 2 " "karakter)." #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 #, fuzzy #| msgid "" #| "Note: For gettys or other login processes, the I field should be the " #| "tty suffix of the corresponding tty, e.g.\\& B<1> for B. " #| "Otherwise, the login accounting might not work correctly." msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" "Megjegyzés: Getty vagy másmilyen login processesknél az I mező a tty " "megfelelő tty rangjának kell lennie, például\\& B<1> a B helyett. " "Másképpen a bejelentkezési nyilvántartás helytelenűl működhet." #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "Leirják, hogy melyik futási szinteken jön létre az adott tevékenység." #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "leírja, hogy milyen tevékenység jöjjön létre." #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:70 #, fuzzy #| msgid "" #| "specifies the process to be executed. If the process field starts with a " #| "`+' character, B will not do utmp and wtmp accounting for that " #| "process. This is needed for gettys that insist on doing their own utmp/" #| "wtmp housekeeping. This is also a historic bug." msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" "Meghatározza, hogy melyik process indítodjon el. Ha a process mező `+' " "karakterrel kezdödik, akkor az init nem csinál utmp és wtmp nyilvántartást a " "processnek. Ez akkor szükséges, ha a getty ragaszkodik a saját utmp/wtmp " "háztartásához. Ez egy történelmi hiba." #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" "A I mező tőbb értéket is tartalmazhat, a különböző " "futásszintekhez. Például az B<123> meghatározza, hogy a programnak az 1-es, " "2-es és 3-as futásszinten kell futnia. Az B futásszint " "bejegyzések lehetnek B, B, vagy B. A B, B, és " "B futásszint bejegyzések figyelmen kívűl lesznek hagyva." #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" "Ha a rendszer futásszintje megváltozik, az összes olyan program, ami az új " "futásszinthez nincs bejegyezve, le lesz álítva, előszőr a \\s-2SIGTERM\\s0, " "majd a \\s-2SIGKILL\\s0 jelzéssel." #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "Érvényes tevékenységek a I mezőhöz:" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "A process újraindul valahányszor megszakítódik (pl:\\& getty)." #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" "A process akkor indul el, amikor a megadott futási szintre lép, és az " "B addig vár, amíg a processz fut.." #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "A processzt egyszer, a futásszintre lépéskor indítja el." #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" "A process a rendszer újrainditása közben indul el. Ilyenkor a I " "mező tartalma nem érdekes." #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" "A processzt a rendszer indulása közben indítja el, az B megvárja míg " "lefut (például:\\& /etc/rc). A I mező mellőzésre kerül." #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "Semmit sem csinál." #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" "Az B (helybeni) futásszinttel megjelölt process elindul, " "valahányszor a megadott helybeni futásszint meghivódik. Viszont nem " "következik be futásszint csere(B futási szintek az `a', a `b' és a " "`c')." #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" "Az B bejegyzés megadja, hogy melyik futási szintre lépünk be a " "rendszer újraindítása után. Ha ilyent nem adtunk meg, akkor az B a " "konzolról kér be egy futásszintet. A I mező ilyenkor figyelmen " "kívűl hagyódik." #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" "A process a rendszer újraindítása alatt hajtódik végre, mégpedig minden " "B és B bejegyzés elött. A I mező tartalma " "lényegtelen." #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 #, fuzzy #| msgid "" #| "The process will be executed when the power goes down. Init is usually " #| "informed about this by a process talking to a UPS connected to the " #| "computer. B will wait for the process to finish before continuing." msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" "A processz akkor lesz végrehajtva, ha megszakad az áramszolgáltatás. Az init " "erről általában egy olyan processztől értesűl, ami egy UPS-sel (szünetmentes " "áramforrás) komunikál. Az B ilyenkor megvárja, hogy a processz " "befelyezödjön mielött továbbmenne." #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" "Ugyanaz, mint a B, kivéve, hogy az B ilyenkor nem várja meg " "a processz befejeződését." #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" "Ez a processz azonnal végre lesz hajtva, amint az B arról értesűl, " "hogy az áram visszatért." #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" "Ez a processz akkor lesz vegrehajtva, ha azt közlik az init-el, hogy a külső " "UPS elemei majdnem teljesen üresek, és az áramszolgáltatás megszünt " "(feltételezi, hogy a külső UPS és az ellenőrző program képes ezt az " "állapotot érzékelni)." #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 #, fuzzy #| msgid "" #| "The process will be executed when B receives the SIGINT signal. " #| "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " #| "B either to get into single-user level or to reboot the machine." msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" "A processz akkor lesz végrehajtva, ha az B egy SIGINT szignált kap. Ez " "azt jelenti, hogy valaki a rendszer konzolján lenyomta a B " "billentyű kombinációt. Általában ez azt jelenti, hogy valaki valamiféle " "B-t akar végrehajtani: vagy egyfelhasználós szintre akar eljutni, " "vagy pedig újra akarja indítani a gépet." #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" "A process akkor lesz végrehajtva, ha az B egy szignált kap a " "billentyűzet kezelötöl, ami azt jelzi, hogy egy speciális billentyű " "kombináció lett lenyomva a konzol billentyűzetén." #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" "Ennek a funkciónak a leírása még nem teljes; további dokumentációt a kbd-x." "xx csomagokban lehet találni (a legújabb a kbd-0.94 csomag volt a " "dokumentácó írása idején). Valószínüleg néhány billentyűzet kombinációt akar " "feltérképezni a \"KeyboardSignal\" akcióhoz. Például, hogy az Alt-" "felfelényíl kombinációt e célból feltérképezze, használja a következöt a " "keymaps fájljában:" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "alt keycode 103 = KeyboardSignal" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "Ez egy példa az inittab-ra, ami emlékeztet a régi Linux-os inittab-ra:" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" "# inittab linux-ra\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" #. type: Plain text #: ../inittab.5:222 #, fuzzy #| msgid "" #| "This inittab file executes B during boot and starts gettys on " #| "tty1-tty4." msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" "Ez az inittab végrehajtja az B paracsfájlt a boot-folyamat alatt és " "elindítja a gettys-t a tty1-tty4-en." #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" "Egy bonyolultabb inittab különbözö futási szintekkel (Lásd a kommenteket a " "fájl-on belül):" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" "# Szint amin fussunk\n" "id:2:initdefault:\n" #. type: Plain text #: ../inittab.5:234 #, fuzzy, no-wrap #| msgid "" #| "# System initialization before anything else.\n" #| "si::sysinit:/etc/rc.d/bcheckrc\n" msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" "# Rendszer inicializáció minden más elött.\n" "si::sysinit:/etc/rc.d/bcheckrc\n" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" "# Mit csináljunk a \"3 ujjas tisztelgés\"-nél.\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" #. type: Plain text #: ../inittab.5:265 #, fuzzy, no-wrap #| msgid "" #| "# Runlevel 2&3: getty on console, level 3 also getty on modem port.\n" #| "1:23:respawn:/sbin/getty tty1 VC linux\n" #| "2:23:respawn:/sbin/getty tty2 VC linux\n" #| "3:23:respawn:/sbin/getty tty3 VC linux\n" #| "4:23:respawn:/sbin/getty tty4 VC linux\n" #| "S2:3:respawn:/sbin/uugetty ttyS2 M19200\n" msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" "# Futásszint 2&3: getty konzolon, 3-as szinten a modemhez is.\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S2:3:respawn:/sbin/uugetty ttyS2 M19200\n" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 #, fuzzy #| msgid "" #| "B was written by Miquel van Smoorenburg (miquels@cistron.nl). This " #| "manual page was written by Sebastian Lederer (lederer@francium.informatik." #| "uni-bonn.de) and modified by Michael Haardt (u31b3hs@pool.informatik.rwth-" #| "aachen.de)." msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "A B-et Miquel van Smoorenburg (miquels@cistron.nl) , a hozzávaló " "kézikönyvlapot pedig Sebastian Lederer (lederer@francium.informatik.uni-bonn." "de) írta és Michael Haardt (u31b3hs@pool.informatik.rwth-aachen.de) " "módosította." #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" #. type: IP #: ../killall5.8:35 #, fuzzy, no-wrap #| msgid "B<-f>, B<--file> I" msgid "B<-o> I" msgstr "B<-f>, B<--file> I" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "" #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "" #. type: TH #: ../last.1:20 #, fuzzy, no-wrap #| msgid "LAST" msgid "LAST," msgstr "LAST" #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 #, fuzzy msgid "last, lastb - show listing of last logged in users" msgstr "" "last, lastb - a legutóbbi belépések listázása terminál vagy felhasználó " "alapján" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" #. type: Plain text #: ../last.1:56 #, fuzzy msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" "A B a B bejegyzéseit dolgozza fel, amely tartalmazza az összes " "információt a be- és kilépésekről, valamint a felhasznált terminálokról. " "Opcionálisan megadhatjuk a felhasználó, vagy a terminál nevét is. Ha több " "opciót adunk meg, akkor minden olyan információt megkapunk, amelyik legalább " "az egyik opcióhoz tartozik: például a ``B'' parancs " "kilistázza a root felhasználó összes belépését és a konzolon történt összes " "többi belépést is. A B időben visszafelé rendezett sorrendben listázza " "ki a belépés idejét, a kapcsolat hosszát és a felhasznált terminál nevét, " "megmutatja a folyamatban lévő kapcsolatokat és a rendszerleállítás miatt " "félbeszakadt kapcsolatokat is." #. type: Plain text #: ../last.1:61 msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" #. type: Plain text #: ../last.1:65 #, fuzzy msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "A B ál-felhasználó jelzi a rendszer újraindításának idejét." #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, fuzzy, no-wrap #| msgid "B<-f>, B<--file> I" msgid "B<-f> I" msgstr "B<-f>, B<--file> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" #. type: IP #: ../last.1:73 #, fuzzy, no-wrap #| msgid "B<->I" msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 #, fuzzy msgid "This is a count telling B how many lines to show." msgstr "A parancs kimenetét korlátozza: legfeljebb ennyi sor jelenhet meg." #. type: IP #: ../last.1:75 #, fuzzy, no-wrap #| msgid "B<->I" msgid "B<-n> I" msgstr "B<->I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "" #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "" #. type: Plain text #: ../last.1:82 msgid "" "Display the state of logins as of the specified time. This is useful, e.g., " "to determine easily who was logged in at a particular time -- specify that " "time with B<-t> and look for \"still logged in\"." msgstr "" #. type: IP #: ../last.1:82 #, no-wrap msgid "B<-R>" msgstr "" #. type: Plain text #: ../last.1:84 msgid "Suppresses the display of the hostname field." msgstr "" #. {{{ -a #. type: IP #: ../last.1:84 ../logsave.8:40 ../shutdown.8:56 #, no-wrap msgid "B<-a>" msgstr "" #. type: Plain text #: ../last.1:87 msgid "" "Display the hostname in the last column. Useful in combination with the next " "flag." msgstr "" #. type: Plain text #: ../last.1:91 msgid "" "For non-local logins, Linux stores not only the host name of the remote host " "but its IP number as well. This option translates the IP number back into a " "hostname." msgstr "" #. type: IP #: ../last.1:91 ../shutdown.8:91 #, no-wrap msgid "B<-F>" msgstr "" #. type: Plain text #: ../last.1:93 msgid "Print full login and logout times and dates." msgstr "" #. type: Plain text #: ../last.1:96 msgid "" "This option is like B<-d> in that it displays the IP number of the remote " "host, but it displays the IP number in numbers-and-dots notation." msgstr "" #. type: IP #: ../last.1:96 #, no-wrap msgid "B<-l>" msgstr "" #. type: Plain text #: ../last.1:100 msgid "" "This option allows the display of usernames longer than 8 characters. This " "may mess up formatting in some programs and make the output wider than the " "standard 80 characters." msgstr "" #. type: IP #: ../last.1:100 ../utmpdump.1:33 #, no-wrap msgid "B<-o>" msgstr "" #. type: Plain text #: ../last.1:102 msgid "Read an old-type wtmp file (written by linux-libc5 applications)." msgstr "" #. type: Plain text #: ../last.1:104 msgid "Display full user and domain names in the output." msgstr "" #. type: IP #: ../last.1:104 ../mountpoint.1:40 ../pidof.8:63 #, no-wrap msgid "B<-x>" msgstr "" #. }}} #. type: Plain text #: ../last.1:107 msgid "Display the system shutdown entries and run level changes." msgstr "" #. {{{ Files #. type: Plain text #: ../last.1:114 msgid "" "The files I and I might not be found. The system only logs " "information in these files if they are present. This is a local " "configuration issue. If you want the files to be used, they can be created " "with a simple B(1) command (for example, B)." msgstr "" #. type: Plain text #: ../last.1:116 msgid "/var/log/wtmp" msgstr "/var/log/wtmp" #. }}} #. {{{ Author #. type: Plain text #: ../last.1:120 msgid "/var/log/btmp" msgstr "/var/log/btmp" #. type: Plain text #: ../last.1:129 #, fuzzy #| msgid "B(8), B(8)" msgid "B(8), B(1), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../logsave.8:5 #, no-wrap msgid "LOGSAVE" msgstr "" #. type: Plain text #: ../logsave.8:8 msgid "logsave - save the output of a command in a logfile" msgstr "" #. type: Plain text #: ../logsave.8:14 msgid "B [ B<-asv> ] I" msgstr "" #. type: Plain text #: ../logsave.8:27 msgid "" "The B program will execute I with the specified " "argument(s), and save a copy of its output to I. If the containing " "directory for I does not exist, B will accumulate the " "output in memory until it can be written out. A copy of the output will " "also be written to standard output." msgstr "" #. type: Plain text #: ../logsave.8:34 msgid "" "If I is a single hyphen ('-'), then instead of executing a " "program, B will take its input from standard input and save it in " "I." msgstr "" #. type: Plain text #: ../logsave.8:39 msgid "" "B is useful for saving the output of initial boot scripts until the " "I partition is mounted, so the output can be written to I." msgstr "" #. type: Plain text #: ../logsave.8:45 msgid "" "This option will cause the output to be appended to I, instead of " "replacing its current contents." msgstr "" #. type: Plain text #: ../logsave.8:53 msgid "" "This option will cause B to skip writing to the log file text which " "is bracketed with a control-A (ASCII 001 or Start of Header) and control-B " "(ASCII 002 or Start of Text). This allows progress bar information to be " "visible to the user on the console, while not being written to the log file." msgstr "" #. type: Plain text #: ../logsave.8:58 msgid "" "This option will make B to be more verbose in its output to the " "user." msgstr "" #. type: Plain text #: ../logsave.8:62 msgid "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" msgstr "" #. type: Plain text #: ../logsave.8:63 msgid "B(8)" msgstr "" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "MESG" msgstr "MESG" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "Feb 26, 2001" msgstr "" #. type: TH #: ../mesg.1:20 ../mountpoint.1:18 ../readbootlog.1:20 ../utmpdump.1:18 #: ../wall.1:18 #, no-wrap msgid "User Commands" msgstr "Felhasználói parancsok" #. }}} #. {{{ Synopsis #. type: Plain text #: ../mesg.1:27 msgid "mesg - control write access to your terminal" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../mesg.1:32 msgid "B [B|B]" msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../mesg.1:38 msgid "" "B controls the access to your terminal by others. It's typically used " "to allow or disallow other users to write to your terminal (see B(1))." msgstr "" #. type: IP #: ../mesg.1:39 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:41 msgid "Allow write access to your terminal." msgstr "" #. type: IP #: ../mesg.1:41 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:43 msgid "Disallow write access to your terminal." msgstr "" #. }}} #. {{{ Notes #. type: Plain text #: ../mesg.1:48 #, fuzzy #| msgid "" #| "If no arguments are given, B shows the current message status on " #| "standard error output." msgid "" "If no option is given, B prints out the current access state of your " "terminal." msgstr "" "Ha a B-et paraméter nélkül indítjuk, akkor az épp aktuális állapotát " "kapjuk meg a szabványos hibakimeneten." #. type: Plain text #: ../mesg.1:53 msgid "" "B assumes that its standard input is connected to your terminal. That " "also means that if you are logged in multiple times, you can get/set the " "mesg status of other sessions by using redirection. For example \"mesg n " "E /dev/pts/46\"." msgstr "" #. type: Plain text #: ../mesg.1:62 #, fuzzy #| msgid "B(1), B(1), B(1), B(1), B(1)" msgid "B(1), B(1), B(1)" msgstr "B(1), B(1), B(1), B(1), B(1)" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "MOUNTPOINT" msgstr "" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "Mar 15, 2004" msgstr "" #. type: Plain text #: ../mountpoint.1:21 msgid "mountpoint - see if a directory is a mountpoint" msgstr "" #. type: Plain text #: ../mountpoint.1:26 msgid "B [B<-q>] [B<-d>] I" msgstr "" #. type: Plain text #: ../mountpoint.1:30 msgid "B B<-x> I" msgstr "" #. type: Plain text #: ../mountpoint.1:32 msgid "B checks if the directory is a mountpoint." msgstr "" #. type: IP #: ../mountpoint.1:34 ../pidof.8:60 ../shutdown.8:107 #, no-wrap msgid "B<-q>" msgstr "" #. type: Plain text #: ../mountpoint.1:36 msgid "Be quiet - don't print anything." msgstr "" #. type: Plain text #: ../mountpoint.1:38 msgid "Print major/minor device number of the filesystem on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:40 msgid "" "Check Linux's I file to try to detect circular mount points." msgstr "" #. type: Plain text #: ../mountpoint.1:42 msgid "Print major/minor device number of the blockdevice on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:44 msgid "Zero if the directory is a mountpoint, non-zero if not." msgstr "" #. type: Plain text #: ../mountpoint.1:48 msgid "" "Symbolic links are not followed, except when the B<-x> option is used. To " "force following symlinks, add a trailing slash to the path of the directory." msgstr "" #. type: Plain text #: ../mountpoint.1:52 msgid "" "The name of the command is misleading when the B<-x> option is used, but the " "option is useful for comparing if a directory and a device match up, and " "there is no other command that can print the info easily." msgstr "" #. type: Plain text #: ../mountpoint.1:57 msgid "" "The mountpoint command fails when a directory is binded to one of its " "grandparents. For example, if /a/b/c/d is a mount point for /a/b then " "mountpoint will report /a/b/c/d is not a valid mount point. This is because " "both the original directory and its new mount point share the same inode and " "device number." msgstr "" #. type: Plain text #: ../mountpoint.1:66 msgid "" "The circular mount problem can be worked around on Linux systems by using " "theB<-p> flag to check the I file for references to the " "circular mount bind. When using the B<-p> flag, make sure to specify the " "full path (ie I and not just I). Also, B may " "still fail if there are spaces in the mount point's path, even when using " "the B<-p> flag because of the way B mangles the spaces in the " "path name. Of course, if the admin is using circular mount points with " "spaces in the name, there are bigger concerns." msgstr "" #. type: Plain text #: ../mountpoint.1:71 msgid "B(1)" msgstr "" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "PIDOF" msgstr "" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "01 Sep 1998" msgstr "" #. type: Plain text #: ../pidof.8:21 msgid "pidof - find the process ID of a running program" msgstr "" #. type: Plain text #: ../pidof.8:36 msgid "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> I] [B<-o> I] [B<-d> I] I " "[I]" msgstr "" #. type: Plain text #: ../pidof.8:44 msgid "" "B finds the process id's (PIDs) of the named programs. It prints " "those id's on the standard output. This program is on some systems used in " "run-level change scripts, especially when the system has a I like " "I structure. In that case these scripts are located in I, " "where ? is the runlevel. If the system has a B(8) program " "that should be used instead." msgstr "" #. type: Plain text #: ../pidof.8:47 msgid "Single shot - this instructs the program to only return one I." msgstr "" #. type: Plain text #: ../pidof.8:51 msgid "" "Only return process PIDs that are running with the same root directory. " "This option is ignored for non-root users, as they will be unable to check " "the current root directory of processes they do not own." msgstr "" #. type: Plain text #: ../pidof.8:60 msgid "" "Avoid B(2) system function call on all binaries which are located on " "network based file systems like B. Instead of using this option the " "variable B may be set and exported." msgstr "" #. type: Plain text #: ../pidof.8:63 msgid "" "Do not display matched PIDs to standard out. Simply exit with a status of " "true or false to indicate whether a matching PID was found." msgstr "" #. type: Plain text #: ../pidof.8:66 msgid "" "Scripts too - this causes the program to also return process id's of shells " "running the named scripts." msgstr "" #. type: IP #: ../pidof.8:66 #, no-wrap msgid "B<-z>" msgstr "" #. type: Plain text #: ../pidof.8:73 msgid "" "Try to detect processes which are stuck in zombie (Z) status. Usually these " "processes are skipped as trying to deal with them can cause pidof or related " "tools to hang. Note: In the past pidof would ignore processes in the " "uninterruptable state (D), unless the B<-z> flag was specified. This is no " "longer the case. The B program will find and report processes in the " "D state whether B<-z> is specified or not." msgstr "" #. type: IP #: ../pidof.8:73 #, no-wrap msgid "-d I" msgstr "" #. type: Plain text #: ../pidof.8:76 msgid "" "Tells I to use I as an output separator if more than one PID is " "shown. The default separator is a space." msgstr "" #. type: IP #: ../pidof.8:76 #, no-wrap msgid "-o I" msgstr "" #. type: Plain text #: ../pidof.8:80 msgid "" "Tells I to omit processes with that process id. The special pid B<" "%PPID> can be used to name the parent process of the B program, in " "other words the calling shell or shell script." msgstr "" #. type: TP #: ../pidof.8:81 #, no-wrap msgid "B<0>" msgstr "B<0>" #. type: Plain text #: ../pidof.8:84 msgid "At least one program was found with the requested name." msgstr "" #. type: TP #: ../pidof.8:84 #, no-wrap msgid "B<1>" msgstr "B<1>" #. type: Plain text #: ../pidof.8:87 msgid "No program was found with the requested name." msgstr "" #. type: Plain text #: ../pidof.8:90 msgid "" "I is actually the same program as B(8); the program behaves " "according to the name under which it is called." msgstr "" #. type: Plain text #: ../pidof.8:98 msgid "" "When B is invoked with a full pathname to the program it should find " "the pid of, it is reasonably safe. Otherwise it is possible that it returns " "PIDs of running programs that happen to have the same name as the program " "you're after but are actually other programs. Note that the executable name " "of running processes is calculated with B(2), so symbolic links to " "executables will also match." msgstr "" #. type: Plain text #: ../pidof.8:103 msgid "" "Zombie processes or processes in disk sleep (states Z and D, respectively) " "are ignored, as attempts to access the stats of these will sometimes fail. " "The B<-z> flag (see above) tells B to try to detect these sleeping " "and zombie processes, at the risk of failing or hanging." msgstr "" #. type: Plain text #: ../pidof.8:110 msgid "B(8), B(8), B(8), B(8), B(8)" msgstr "" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "READBOOTLOG" msgstr "" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "NOV 12, 2018" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../readbootlog.1:27 msgid "" "readbootlog - show contents of the boot log, stripping away control " "characters" msgstr "" #. type: Plain text #: ../readbootlog.1:31 msgid "B [B<-h>] [-B I]" msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../readbootlog.1:42 msgid "" "B is a tool for reading the boot log (by default I). The program strips away control characters and non-human readable " "contents from the log file. Output is dumped to the terminal where it can be " "piped or redirected to a file." msgstr "" #. type: Plain text #: ../readbootlog.1:45 msgid "" "Tells B to use a specific file instead of I." msgstr "" #. {{{ Files #. type: Plain text #: ../readbootlog.1:48 msgid "Displays a brief help message." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../readbootlog.1:52 #, fuzzy #| msgid "/var/log/btmp" msgid "/var/log/boot" msgstr "/var/log/btmp" #. }}} #. {{{ See also #. type: Plain text #: ../readbootlog.1:58 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" msgstr "" #. type: Plain text #: ../readbootlog.1:59 #, fuzzy #| msgid "B" msgid "B(8)" msgstr "B" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "RUNLEVEL" msgstr "" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "May 27, 1997" msgstr "" #. type: Plain text #: ../runlevel.8:21 msgid "runlevel - find the previous and current system runlevel" msgstr "" #. type: Plain text #: ../runlevel.8:24 #, fuzzy #| msgid "I" msgid "B [I]" msgstr "I" #. type: Plain text #: ../runlevel.8:34 msgid "" "B reads the system I file (typically I) to " "locate the runlevel record, and then prints the previous and current system " "runlevel on its standard output, separated by a single space. If there is no " "previous system runlevel, the letter B will be printed instead." msgstr "" #. type: Plain text #: ../runlevel.8:42 msgid "" "If no I file exists, and if no runlevel record can be found in the I file, B prints the word B and exits " "with an error." msgstr "" #. type: Plain text #: ../runlevel.8:49 msgid "" "B can be used in I scripts as a substitute for the System-V " "B command. However, in newer versions of B(8) this " "information is also available in the environment variables B and " "B." msgstr "" #. {{{ utmp #. type: IP #: ../runlevel.8:51 #, no-wrap msgid "I" msgstr "" #. }}} #. type: Plain text #: ../runlevel.8:54 msgid "The name of the I file to read." msgstr "" #. type: Plain text #: ../runlevel.8:57 #, fuzzy #| msgid "B(8), B(8)" msgid "B(8), B(5)" msgstr "B(8), B(8)" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "SHUTDOWN" msgstr "" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "November 12, 2003" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../shutdown.8:27 msgid "shutdown - bring the system down" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../shutdown.8:36 msgid "" "B [B<-akrhPHfFncqQ>] [B<-t> I] I,B,B" msgid "B, B, B" msgstr "B,B,B" #. type: Plain text #: ../init.8:175 msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "B atau B" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "" #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "B atau B" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "" #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "B atau B" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "I" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "" #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "" #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "B<-s, S, single>" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "B<1-5>" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "" #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "B<-b, emergency>" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "B<-a, auto>" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "B<-z >I" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "" #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "BERKAS" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "INITCTL" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "13 April 2018" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "/run/initctl" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "" #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "/run/initctl /sbin/init" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "INITSCRIPT" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "10 Juli 2003" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" #. type: Plain text #: ../initscript.5:65 msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "/etc/inittab, /etc/initscript." #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "B(5), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "4 Desember 2001" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "" #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:48 msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "" #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "" #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "" #. type: Plain text #: ../inittab.5:70 msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "" #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "" #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "" #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" #. type: Plain text #: ../inittab.5:222 msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" #. type: Plain text #: ../inittab.5:234 #, no-wrap msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" #. type: Plain text #: ../inittab.5:265 #, no-wrap msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "KILLALL5" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "4 November 2003" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" #. type: IP #: ../killall5.8:35 #, fuzzy, no-wrap #| msgid "B<-f>, B<--force>" msgid "B<-o> I" msgstr "B<-f>, B<--force>" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "" #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "B(8), B(8), B(8)" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "LAST," #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "1" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "31 Juli 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" #. type: Plain text #: ../last.1:56 msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" #. type: Plain text #: ../last.1:61 msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "B<-f> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" #. type: IP #: ../last.1:73 #, no-wrap msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 msgid "This is a count telling B how many lines to show." msgstr "" #. type: IP #: ../last.1:75 #, no-wrap msgid "B<-n> I" msgstr "B<-n> I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "" #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "" #. type: Plain text #: ../last.1:82 msgid "" "Display the state of logins as of the specified time. This is useful, e.g., " "to determine easily who was logged in at a particular time -- specify that " "time with B<-t> and look for \"still logged in\"." msgstr "" #. type: IP #: ../last.1:82 #, no-wrap msgid "B<-R>" msgstr "B<-R>" #. type: Plain text #: ../last.1:84 msgid "Suppresses the display of the hostname field." msgstr "" #. {{{ -a #. type: IP #: ../last.1:84 ../logsave.8:40 ../shutdown.8:56 #, no-wrap msgid "B<-a>" msgstr "B<-a>" #. type: Plain text #: ../last.1:87 msgid "" "Display the hostname in the last column. Useful in combination with the next " "flag." msgstr "" #. type: Plain text #: ../last.1:91 msgid "" "For non-local logins, Linux stores not only the host name of the remote host " "but its IP number as well. This option translates the IP number back into a " "hostname." msgstr "" #. type: IP #: ../last.1:91 ../shutdown.8:91 #, no-wrap msgid "B<-F>" msgstr "B<-F>" #. type: Plain text #: ../last.1:93 msgid "Print full login and logout times and dates." msgstr "" #. type: Plain text #: ../last.1:96 msgid "" "This option is like B<-d> in that it displays the IP number of the remote " "host, but it displays the IP number in numbers-and-dots notation." msgstr "" #. type: IP #: ../last.1:96 #, no-wrap msgid "B<-l>" msgstr "B<-l>" #. type: Plain text #: ../last.1:100 msgid "" "This option allows the display of usernames longer than 8 characters. This " "may mess up formatting in some programs and make the output wider than the " "standard 80 characters." msgstr "" #. type: IP #: ../last.1:100 ../utmpdump.1:33 #, no-wrap msgid "B<-o>" msgstr "B<-o>" #. type: Plain text #: ../last.1:102 msgid "Read an old-type wtmp file (written by linux-libc5 applications)." msgstr "" #. type: Plain text #: ../last.1:104 msgid "Display full user and domain names in the output." msgstr "" #. type: IP #: ../last.1:104 ../mountpoint.1:40 ../pidof.8:63 #, no-wrap msgid "B<-x>" msgstr "B<-x>" #. }}} #. type: Plain text #: ../last.1:107 msgid "Display the system shutdown entries and run level changes." msgstr "" #. {{{ Files #. type: Plain text #: ../last.1:114 msgid "" "The files I and I might not be found. The system only logs " "information in these files if they are present. This is a local " "configuration issue. If you want the files to be used, they can be created " "with a simple B(1) command (for example, B)." msgstr "" #. type: Plain text #: ../last.1:116 msgid "/var/log/wtmp" msgstr "/var/log/wtmp" #. }}} #. {{{ Author #. type: Plain text #: ../last.1:120 msgid "/var/log/btmp" msgstr "/var/log/btmp" #. type: Plain text #: ../last.1:129 msgid "B(8), B(1), B(8)" msgstr "B(8), B(1), B(8)" #. type: TH #: ../logsave.8:5 #, no-wrap msgid "LOGSAVE" msgstr "LOGSAVE" #. type: Plain text #: ../logsave.8:8 msgid "logsave - save the output of a command in a logfile" msgstr "" #. type: Plain text #: ../logsave.8:14 msgid "B [ B<-asv> ] I" msgstr "" #. type: Plain text #: ../logsave.8:27 msgid "" "The B program will execute I with the specified " "argument(s), and save a copy of its output to I. If the containing " "directory for I does not exist, B will accumulate the " "output in memory until it can be written out. A copy of the output will " "also be written to standard output." msgstr "" #. type: Plain text #: ../logsave.8:34 msgid "" "If I is a single hyphen ('-'), then instead of executing a " "program, B will take its input from standard input and save it in " "I." msgstr "" #. type: Plain text #: ../logsave.8:39 msgid "" "B is useful for saving the output of initial boot scripts until the " "I partition is mounted, so the output can be written to I." msgstr "" #. type: Plain text #: ../logsave.8:45 msgid "" "This option will cause the output to be appended to I, instead of " "replacing its current contents." msgstr "" #. type: Plain text #: ../logsave.8:53 msgid "" "This option will cause B to skip writing to the log file text which " "is bracketed with a control-A (ASCII 001 or Start of Header) and control-B " "(ASCII 002 or Start of Text). This allows progress bar information to be " "visible to the user on the console, while not being written to the log file." msgstr "" #. type: Plain text #: ../logsave.8:58 msgid "" "This option will make B to be more verbose in its output to the " "user." msgstr "" #. type: Plain text #: ../logsave.8:62 msgid "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" msgstr "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" #. type: Plain text #: ../logsave.8:63 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "MESG" msgstr "MESG" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "Feb 26, 2001" msgstr "26 Februari 2001" #. type: TH #: ../mesg.1:20 ../mountpoint.1:18 ../readbootlog.1:20 ../utmpdump.1:18 #: ../wall.1:18 #, no-wrap msgid "User Commands" msgstr "Penggunaan halaman buku panduan" #. }}} #. {{{ Synopsis #. type: Plain text #: ../mesg.1:27 msgid "mesg - control write access to your terminal" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../mesg.1:32 msgid "B [B|B]" msgstr "B [B|B]" #. }}} #. {{{ Options #. type: Plain text #: ../mesg.1:38 msgid "" "B controls the access to your terminal by others. It's typically used " "to allow or disallow other users to write to your terminal (see B(1))." msgstr "" #. type: IP #: ../mesg.1:39 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:41 msgid "Allow write access to your terminal." msgstr "" #. type: IP #: ../mesg.1:41 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:43 msgid "Disallow write access to your terminal." msgstr "" #. }}} #. {{{ Notes #. type: Plain text #: ../mesg.1:48 msgid "" "If no option is given, B prints out the current access state of your " "terminal." msgstr "" #. type: Plain text #: ../mesg.1:53 msgid "" "B assumes that its standard input is connected to your terminal. That " "also means that if you are logged in multiple times, you can get/set the " "mesg status of other sessions by using redirection. For example \"mesg n " "E /dev/pts/46\"." msgstr "" #. type: Plain text #: ../mesg.1:62 msgid "B(1), B(1), B(1)" msgstr "B(1), B(1), B(1)" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "MOUNTPOINT" msgstr "MOUNTPOINT" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "Mar 15, 2004" msgstr "15 Maret 2004" #. type: Plain text #: ../mountpoint.1:21 msgid "mountpoint - see if a directory is a mountpoint" msgstr "" #. type: Plain text #: ../mountpoint.1:26 msgid "B [B<-q>] [B<-d>] I" msgstr "" #. type: Plain text #: ../mountpoint.1:30 msgid "B B<-x> I" msgstr "" #. type: Plain text #: ../mountpoint.1:32 msgid "B checks if the directory is a mountpoint." msgstr "" #. type: IP #: ../mountpoint.1:34 ../pidof.8:60 ../shutdown.8:107 #, no-wrap msgid "B<-q>" msgstr "B<-q>" #. type: Plain text #: ../mountpoint.1:36 msgid "Be quiet - don't print anything." msgstr "" #. type: Plain text #: ../mountpoint.1:38 msgid "Print major/minor device number of the filesystem on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:40 msgid "" "Check Linux's I file to try to detect circular mount points." msgstr "" #. type: Plain text #: ../mountpoint.1:42 msgid "Print major/minor device number of the blockdevice on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:44 msgid "Zero if the directory is a mountpoint, non-zero if not." msgstr "" #. type: Plain text #: ../mountpoint.1:48 msgid "" "Symbolic links are not followed, except when the B<-x> option is used. To " "force following symlinks, add a trailing slash to the path of the directory." msgstr "" #. type: Plain text #: ../mountpoint.1:52 msgid "" "The name of the command is misleading when the B<-x> option is used, but the " "option is useful for comparing if a directory and a device match up, and " "there is no other command that can print the info easily." msgstr "" #. type: Plain text #: ../mountpoint.1:57 msgid "" "The mountpoint command fails when a directory is binded to one of its " "grandparents. For example, if /a/b/c/d is a mount point for /a/b then " "mountpoint will report /a/b/c/d is not a valid mount point. This is because " "both the original directory and its new mount point share the same inode and " "device number." msgstr "" #. type: Plain text #: ../mountpoint.1:66 msgid "" "The circular mount problem can be worked around on Linux systems by using " "theB<-p> flag to check the I file for references to the " "circular mount bind. When using the B<-p> flag, make sure to specify the " "full path (ie I and not just I). Also, B may " "still fail if there are spaces in the mount point's path, even when using " "the B<-p> flag because of the way B mangles the spaces in the " "path name. Of course, if the admin is using circular mount points with " "spaces in the name, there are bigger concerns." msgstr "" #. type: Plain text #: ../mountpoint.1:71 msgid "B(1)" msgstr "B(1)" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "PIDOF" msgstr "PIDOF" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "01 Sep 1998" msgstr "1 September 1998" #. type: Plain text #: ../pidof.8:21 msgid "pidof - find the process ID of a running program" msgstr "" #. type: Plain text #: ../pidof.8:36 msgid "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> I] [B<-o> I] [B<-d> I] I " "[I]" msgstr "" #. type: Plain text #: ../pidof.8:44 msgid "" "B finds the process id's (PIDs) of the named programs. It prints " "those id's on the standard output. This program is on some systems used in " "run-level change scripts, especially when the system has a I like " "I structure. In that case these scripts are located in I, " "where ? is the runlevel. If the system has a B(8) program " "that should be used instead." msgstr "" #. type: Plain text #: ../pidof.8:47 msgid "Single shot - this instructs the program to only return one I." msgstr "" #. type: Plain text #: ../pidof.8:51 msgid "" "Only return process PIDs that are running with the same root directory. " "This option is ignored for non-root users, as they will be unable to check " "the current root directory of processes they do not own." msgstr "" #. type: Plain text #: ../pidof.8:60 msgid "" "Avoid B(2) system function call on all binaries which are located on " "network based file systems like B. Instead of using this option the " "variable B may be set and exported." msgstr "" #. type: Plain text #: ../pidof.8:63 msgid "" "Do not display matched PIDs to standard out. Simply exit with a status of " "true or false to indicate whether a matching PID was found." msgstr "" #. type: Plain text #: ../pidof.8:66 msgid "" "Scripts too - this causes the program to also return process id's of shells " "running the named scripts." msgstr "" #. type: IP #: ../pidof.8:66 #, no-wrap msgid "B<-z>" msgstr "B<-z>" #. type: Plain text #: ../pidof.8:73 msgid "" "Try to detect processes which are stuck in zombie (Z) status. Usually these " "processes are skipped as trying to deal with them can cause pidof or related " "tools to hang. Note: In the past pidof would ignore processes in the " "uninterruptable state (D), unless the B<-z> flag was specified. This is no " "longer the case. The B program will find and report processes in the " "D state whether B<-z> is specified or not." msgstr "" #. type: IP #: ../pidof.8:73 #, no-wrap msgid "-d I" msgstr "" #. type: Plain text #: ../pidof.8:76 msgid "" "Tells I to use I as an output separator if more than one PID is " "shown. The default separator is a space." msgstr "" #. type: IP #: ../pidof.8:76 #, no-wrap msgid "-o I" msgstr "" #. type: Plain text #: ../pidof.8:80 msgid "" "Tells I to omit processes with that process id. The special pid B<" "%PPID> can be used to name the parent process of the B program, in " "other words the calling shell or shell script." msgstr "" #. type: TP #: ../pidof.8:81 #, no-wrap msgid "B<0>" msgstr "B<0>" #. type: Plain text #: ../pidof.8:84 msgid "At least one program was found with the requested name." msgstr "" #. type: TP #: ../pidof.8:84 #, no-wrap msgid "B<1>" msgstr "B<1>" #. type: Plain text #: ../pidof.8:87 msgid "No program was found with the requested name." msgstr "" #. type: Plain text #: ../pidof.8:90 msgid "" "I is actually the same program as B(8); the program behaves " "according to the name under which it is called." msgstr "" #. type: Plain text #: ../pidof.8:98 msgid "" "When B is invoked with a full pathname to the program it should find " "the pid of, it is reasonably safe. Otherwise it is possible that it returns " "PIDs of running programs that happen to have the same name as the program " "you're after but are actually other programs. Note that the executable name " "of running processes is calculated with B(2), so symbolic links to " "executables will also match." msgstr "" #. type: Plain text #: ../pidof.8:103 msgid "" "Zombie processes or processes in disk sleep (states Z and D, respectively) " "are ignored, as attempts to access the stats of these will sometimes fail. " "The B<-z> flag (see above) tells B to try to detect these sleeping " "and zombie processes, at the risk of failing or hanging." msgstr "" #. type: Plain text #: ../pidof.8:110 msgid "B(8), B(8), B(8), B(8), B(8)" msgstr "B(8), B(8), B(8), B(8), B(8)" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "READBOOTLOG" msgstr "READBOOTLOG" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "NOV 12, 2018" msgstr "12 November 2018" #. }}} #. {{{ Synopsis #. type: Plain text #: ../readbootlog.1:27 msgid "" "readbootlog - show contents of the boot log, stripping away control " "characters" msgstr "" #. type: Plain text #: ../readbootlog.1:31 msgid "B [B<-h>] [-B I]" msgstr "B [B<-h>] [-B I]" #. }}} #. {{{ Options #. type: Plain text #: ../readbootlog.1:42 msgid "" "B is a tool for reading the boot log (by default I). The program strips away control characters and non-human readable " "contents from the log file. Output is dumped to the terminal where it can be " "piped or redirected to a file." msgstr "" #. type: Plain text #: ../readbootlog.1:45 msgid "" "Tells B to use a specific file instead of I." msgstr "" #. {{{ Files #. type: Plain text #: ../readbootlog.1:48 msgid "Displays a brief help message." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../readbootlog.1:52 msgid "/var/log/boot" msgstr "/var/log/boot" #. }}} #. {{{ See also #. type: Plain text #: ../readbootlog.1:58 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" #. type: Plain text #: ../readbootlog.1:59 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "RUNLEVEL" msgstr "RUNLEVEL" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "May 27, 1997" msgstr "27 Mei 1997" #. type: Plain text #: ../runlevel.8:21 msgid "runlevel - find the previous and current system runlevel" msgstr "" #. type: Plain text #: ../runlevel.8:24 msgid "B [I]" msgstr "" #. type: Plain text #: ../runlevel.8:34 msgid "" "B reads the system I file (typically I) to " "locate the runlevel record, and then prints the previous and current system " "runlevel on its standard output, separated by a single space. If there is no " "previous system runlevel, the letter B will be printed instead." msgstr "" #. type: Plain text #: ../runlevel.8:42 msgid "" "If no I file exists, and if no runlevel record can be found in the I file, B prints the word B and exits " "with an error." msgstr "" #. type: Plain text #: ../runlevel.8:49 msgid "" "B can be used in I scripts as a substitute for the System-V " "B command. However, in newer versions of B(8) this " "information is also available in the environment variables B and " "B." msgstr "" #. {{{ utmp #. type: IP #: ../runlevel.8:51 #, no-wrap msgid "I" msgstr "" #. }}} #. type: Plain text #: ../runlevel.8:54 msgid "The name of the I file to read." msgstr "" #. type: Plain text #: ../runlevel.8:57 msgid "B(8), B(5)" msgstr "B(8), B(5)" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "SHUTDOWN" msgstr "SHUTDOWN" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "November 12, 2003" msgstr "12 November 2003" #. }}} #. {{{ Synopsis #. type: Plain text #: ../shutdown.8:27 msgid "shutdown - bring the system down" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../shutdown.8:36 msgid "" "B [B<-akrhPHfFncqQ>] [B<-t> I] I," #~ msgstr "B," #~ msgid "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgstr "Miquel van Smoorenburg, miquels@cistron.nl" #, no-wrap #~ msgid "fstab-decode" #~ msgstr "fstab-decode" #~ msgid "Jesse Smith Ejsmith@resonatingmedia.comE" #~ msgstr "Jesse Smith Ejsmith@resonatingmedia.comE" #~ msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #, no-wrap #~ msgid "@E2FSPROGS_MONTH@ @E2FSPROGS_YEAR@" #~ msgstr "@E2FSPROGS_MONTH@ @E2FSPROGS_YEAR@" #~ msgid "Theodore Ts'o (tytso@mit.edu)" #~ msgstr "Theodore Ts'o (tytso@mit.edu)" #~ msgid "Miquel van Smoorenburg (miquels@cistron.nl)" #~ msgstr "Miquel van Smoorenburg (miquels@cistron.nl)" #, no-wrap #~ msgid "-s" #~ msgstr "-s" #, no-wrap #~ msgid "-c" #~ msgstr "-c" #, no-wrap #~ msgid "-n" #~ msgstr "-n" #, no-wrap #~ msgid "-q" #~ msgstr "-q" #, no-wrap #~ msgid "-x" #~ msgstr "-x" #, no-wrap #~ msgid "-z" #~ msgstr "-z" #~ msgid "Miquel van Smoorenburg Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg Emiquels@cistron.nlE" #, no-wrap #~ msgid "systemd 249" #~ msgstr "systemd 249" #, no-wrap #~ msgid "halt" #~ msgstr "halt" #~ msgid "B [OPTIONS...]" #~ msgstr "B [PILIHAN...]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [PILIHAN...]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [PILIHAN...]" #~ msgid "B<--help>" #~ msgstr "B<--help>" #, fuzzy #~ msgid "Print a short help text and exit\\&." #~ msgstr "Tampilkan sebuah pesan bantuan dan keluar." #~ msgid "B<--halt>" #~ msgstr "B<--halt>" #~ msgid "B<-p>, B<--poweroff>" #~ msgstr "B<-p>, B<--poweroff>" #~ msgid "B<-w>, B<--wtmp-only>" #~ msgstr "B<-w>, B<--wtmp-only>" #~ msgid "B<-d>, B<--no-wtmp>" #~ msgstr "B<-d>, B<--no-wtmp>" #~ msgid "B<-n>, B<--no-sync>" #~ msgstr "B<-n>, B<--no-sync>" #~ msgid "B<--no-wall>" #~ msgstr "B<--no-wall>" #~ msgid "B(1), B(1), B(8), B(1)" #~ msgstr "B(1), B(1), B(8), B(1)" #, fuzzy, no-wrap #~ msgid "systemd 250" #~ msgstr "systemd 249" #, fuzzy #~ msgid "shutdown - Halt, power-off or reboot the machine" #~ msgstr "shutdown - menghentikan sistem" #~ msgid "B<-H>, B<--halt>" #~ msgstr "B<-H>, B<--halt>" #~ msgid "B<-P>, B<--poweroff>" #~ msgstr "B<-P>, B<--poweroff>" #~ msgid "B<-r>, B<--reboot>" #~ msgstr "B<-r>, B<--reboot>" sysvinit-3.14/man/po/pl.po000066400000000000000000005137761475234444100155300ustar00rootroot00000000000000# Polish translation of the sysvinit man pages. # Marcin Garski , 1997. # Paweł Wilk , 1998. # Przemek Borys , 1998-1999. # Wojtek Kotwica , 1999-2000. # Robert Luberda , 2005, 2017. # Szymon Lamkiewicz , 2020. # Michał Kułach , 2012-2013, 2016, 2021. msgid "" msgstr "" "Project-Id-Version: sysvinit-man\n" "Report-Msgid-Bugs-To: Your Bugmail \n" "POT-Creation-Date: 2022-05-01 15:59-0300\n" "PO-Revision-Date: 2021-03-17 19:36+0100\n" "Last-Translator: Michał Kułach \n" "Language-Team: Polish \n" "Language: pl\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #. type: TH #: ../bootlogd.8:18 #, no-wrap msgid "BOOTLOGD" msgstr "BOOTLOGD" #. type: TH #: ../bootlogd.8:18 #, no-wrap msgid "Jul 21, 2003" msgstr "21 lipca 2003" #. type: TH #: ../bootlogd.8:18 ../fstab-decode.8:20 ../halt.8:20 ../init.8:20 #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 ../killall5.8:18 #: ../last.1:20 ../logsave.8:5 ../mesg.1:20 ../mountpoint.1:18 ../pidof.8:18 #: ../readbootlog.1:20 ../runlevel.8:18 ../shutdown.8:20 ../sulogin.8:18 #: ../utmpdump.1:18 ../wall.1:18 #, fuzzy, no-wrap #| msgid "B" msgid "sysvinit " msgstr "B" #. type: TH #: ../bootlogd.8:18 ../fstab-decode.8:20 ../halt.8:20 ../init.8:20 #: ../killall5.8:18 ../logsave.8:5 ../pidof.8:18 ../runlevel.8:18 #: ../shutdown.8:20 ../sulogin.8:18 #, no-wrap msgid "Linux System Administrator's Manual" msgstr "Podręcznik administratora systemu Linux" #. type: SH #: ../bootlogd.8:19 ../fstab-decode.8:22 ../halt.8:23 ../init.8:23 #: ../initctl.5:18 ../initscript.5:19 ../inittab.5:23 ../killall5.8:19 #: ../last.1:23 ../logsave.8:6 ../mesg.1:23 ../mountpoint.1:19 ../pidof.8:19 #: ../readbootlog.1:23 ../runlevel.8:19 ../shutdown.8:23 ../sulogin.8:19 #: ../utmpdump.1:19 ../wall.1:20 #, no-wrap msgid "NAME" msgstr "NAZWA" #. type: Plain text #: ../bootlogd.8:21 msgid "bootlogd - record boot messages" msgstr "" #. type: SH #: ../bootlogd.8:21 ../fstab-decode.8:25 ../halt.8:27 ../init.8:27 #: ../initctl.5:20 ../initscript.5:21 ../killall5.8:21 ../last.1:27 #: ../logsave.8:8 ../mesg.1:27 ../mountpoint.1:21 ../pidof.8:21 #: ../readbootlog.1:27 ../runlevel.8:21 ../shutdown.8:27 ../sulogin.8:21 #: ../utmpdump.1:21 ../wall.1:23 #, no-wrap msgid "SYNOPSIS" msgstr "SKŁADNIA" #. type: Plain text #: ../bootlogd.8:31 #, fuzzy #| msgid "" #| "B [B< -a >] [B< -s >] [B< -b >] [ B<-z> I ] [B< " #| "0123456Ss >]" msgid "" "B [B<-c>] [B<-d>] [B<-e>] [B<-r>] [B<-s>] [B<-v>] [I< >B<-" "l>I< logfile >] [I< >B<-p>I< pidfile >]" msgstr "" "B [B< -a >] [B< -s >] [B< -b >] [B< -z> I] [B< 0123456Ss >]" #. type: SH #: ../bootlogd.8:31 ../fstab-decode.8:28 ../halt.8:53 ../init.8:46 #: ../initctl.5:22 ../initscript.5:23 ../inittab.5:28 ../killall5.8:28 #: ../last.1:48 ../logsave.8:14 ../mesg.1:32 ../mountpoint.1:30 ../pidof.8:36 #: ../readbootlog.1:34 ../runlevel.8:24 ../shutdown.8:36 ../sulogin.8:27 #: ../utmpdump.1:25 ../wall.1:28 #, no-wrap msgid "DESCRIPTION" msgstr "OPIS" #. type: Plain text #: ../bootlogd.8:35 msgid "" "B runs in the background and copies all strings sent to the I device to a logfile. If the I is not accessible, the " "messages will be kept in memory until it is." msgstr "" #. type: SH #: ../bootlogd.8:35 ../halt.8:68 ../killall5.8:34 ../last.1:70 ../logsave.8:39 #: ../mesg.1:38 ../mountpoint.1:33 ../pidof.8:44 ../readbootlog.1:42 #: ../runlevel.8:49 ../shutdown.8:54 ../utmpdump.1:28 ../wall.1:52 #, no-wrap msgid "OPTIONS" msgstr "OPCJE" #. type: IP #: ../bootlogd.8:36 ../halt.8:75 ../last.1:87 ../mountpoint.1:36 #, no-wrap msgid "B<-d>" msgstr "B<-d>" #. type: Plain text #: ../bootlogd.8:38 msgid "Do not fork and run in the background." msgstr "" #. type: IP #: ../bootlogd.8:38 #, no-wrap msgid "B<-e>" msgstr "B<-e>" #. type: Plain text #: ../bootlogd.8:42 msgid "" "Print escape characters to the boot log file. This turns off filtering of " "escape characters and allows tools like GNU B(1) to see and use colour " "control characters (show the log in colour)." msgstr "" #. type: IP #: ../bootlogd.8:42 ../pidof.8:47 ../shutdown.8:101 #, no-wrap msgid "B<-c>" msgstr "B<-c>" #. type: Plain text #: ../bootlogd.8:47 msgid "" "Attempt to write to the logfile even if it does not yet exist. Without this " "option, B will wait for the logfile to appear before attempting to " "write to it. This behavior prevents B from creating logfiles under " "mount points." msgstr "" #. type: IP #: ../bootlogd.8:47 ../shutdown.8:64 ../utmpdump.1:31 #, no-wrap msgid "B<-r>" msgstr "B<-r>" #. type: Plain text #: ../bootlogd.8:50 msgid "" "If there is an existing logfile called I rename it to I " "unless I already exists." msgstr "" #. type: IP #: ../bootlogd.8:50 ../logsave.8:45 ../pidof.8:45 #, no-wrap msgid "B<-s>" msgstr "B<-s>" #. type: Plain text #: ../bootlogd.8:56 msgid "" "Ensure that the data is written to the file after each line by calling " "B(3). This will slow down a B(8) process running in " "parallel." msgstr "" #. type: TP #: ../bootlogd.8:56 ../logsave.8:53 #, no-wrap msgid "B<-v>" msgstr "B<-v>" #. type: Plain text #: ../bootlogd.8:58 msgid "Show version." msgstr "" #. type: IP #: ../bootlogd.8:58 #, fuzzy, no-wrap #| msgid "B<-f>, B<--file> I" msgid "B<-l> I" msgstr "B<-f>, B<--file> I" #. type: Plain text #: ../bootlogd.8:60 msgid "Log to this logfile. The default is I." msgstr "" #. type: IP #: ../bootlogd.8:60 #, fuzzy, no-wrap #| msgid "B<-f>, B<--file> I" msgid "B<-p> I" msgstr "B<-f>, B<--file> I" #. type: Plain text #: ../bootlogd.8:62 msgid "Put process-id in this file. The default is no pidfile." msgstr "" #. }}} #. type: SH #: ../bootlogd.8:62 ../halt.8:94 ../initctl.5:119 ../initscript.5:60 #: ../killall5.8:37 ../last.1:107 ../mesg.1:48 ../mountpoint.1:44 ../pidof.8:87 #: ../shutdown.8:216 #, no-wrap msgid "NOTES" msgstr "UWAGI" #. type: Plain text #: ../bootlogd.8:67 msgid "" "B saves log data which includes control characters. The log is " "technically a text file, but not very easy for humans to read. To address " "this the B(1) command can be used to display the boot log " "without the control characters." msgstr "" #. type: SH #: ../bootlogd.8:67 ../utmpdump.1:52 #, no-wrap msgid "BUGS" msgstr "" #. type: Plain text #: ../bootlogd.8:77 msgid "" "B works by redirecting the console output from the console " "device. (Consequently B requires PTY support in the kernel " "configuration.) It copies that output to the real console device and to a " "log file. There is no standard way of ascertaining the real console device " "if you have a new-style I device (major 5, minor 1) so " "B parses the kernel command line looking for B lines " "and deduces the real console device from that. If that syntax is ever " "changed by the kernel, or a console type is used that B does not " "know about then B will not work." msgstr "" #. type: SH #: ../bootlogd.8:78 ../halt.8:116 ../init.8:337 ../initctl.5:147 #: ../initscript.5:68 ../inittab.5:275 ../killall5.8:48 ../last.1:120 #: ../logsave.8:58 ../mesg.1:53 ../mountpoint.1:66 ../pidof.8:110 #: ../readbootlog.1:52 ../runlevel.8:57 ../shutdown.8:232 ../sulogin.8:84 #: ../utmpdump.1:60 ../wall.1:74 #, no-wrap msgid "AUTHOR" msgstr "AUTOR" #. type: Plain text #: ../bootlogd.8:82 ../halt.8:122 ../initscript.5:72 ../killall5.8:51 #: ../last.1:126 ../mesg.1:59 ../mountpoint.1:70 ../pidof.8:113 #: ../runlevel.8:60 ../shutdown.8:238 ../sulogin.8:88 ../wall.1:77 msgid "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>" msgstr "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>" #. type: SH #: ../bootlogd.8:82 ../fstab-decode.8:67 ../halt.8:122 ../init.8:346 #: ../initctl.5:151 ../initscript.5:72 ../inittab.5:290 ../killall5.8:44 #: ../last.1:126 ../logsave.8:62 ../mesg.1:59 ../mountpoint.1:70 ../pidof.8:104 #: ../readbootlog.1:58 ../runlevel.8:54 ../shutdown.8:238 ../sulogin.8:88 #: ../utmpdump.1:62 ../wall.1:70 #, no-wrap msgid "SEE ALSO" msgstr "ZOBACZ TAKŻE" #. type: Plain text #: ../bootlogd.8:85 msgid "B(8), B(3), B(1)" msgstr "B(8), B(3), B(1)" #. type: TH #: ../fstab-decode.8:20 #, no-wrap msgid "FSTAB-DECODE" msgstr "FSTAB-DECODE" #. type: TH #: ../fstab-decode.8:20 #, no-wrap msgid "May 2006" msgstr "" #. type: Plain text #: ../fstab-decode.8:24 msgid "fstab-decode - run a command with fstab-encoded arguments" msgstr "" #. type: Plain text #: ../fstab-decode.8:27 msgid "B I [I]..." msgstr "" #. type: Plain text #: ../fstab-decode.8:34 msgid "" "B decodes escapes (such as newline characters and other " "whitespace) in the specified Is and uses them to run I. " "The argument escaping uses the same rules as path escaping in I, " "I and I." msgstr "" #. type: Plain text #: ../fstab-decode.8:38 msgid "" "In essence B can be used anytime we want to pass multiple " "parameters to a command as a list of command line arguments. It turns output " "like this:" msgstr "" #. type: Plain text #: ../fstab-decode.8:43 #, no-wrap msgid "" "/root\n" "/mnt/remote-disk\n" "/home\n" msgstr "" #. type: Plain text #: ../fstab-decode.8:49 #, no-wrap msgid "" "Into one long list of parameters, \"/root /mnt/remote-disk /home\". This\n" "can be useful when trying to work with multiple filesystems at once. For\n" "instance, we can use it to unmount multiple NFS shares. This program also\n" "removes whitespace and other characters which might cause programs such\n" "as B(8) or B(8) to fail.\n" msgstr "" #. type: SH #: ../fstab-decode.8:50 ../killall5.8:40 ../mountpoint.1:42 ../pidof.8:80 #, no-wrap msgid "EXIT STATUS" msgstr "KOD ZAKOŃCZENIA" #. type: Plain text #: ../fstab-decode.8:56 msgid "" "B exits with status 127 if I can't be run. Otherwise " "it exits with the status returned by I." msgstr "" #. }}} #. }}} #. {{{ Examples #. type: SH #: ../fstab-decode.8:57 ../initctl.5:93 ../initscript.5:28 ../inittab.5:204 #, no-wrap msgid "EXAMPLES" msgstr "PRZYKŁADY" #. type: Plain text #: ../fstab-decode.8:62 msgid "" "The following example reads I, finds all instances of VFAT " "filesystems and prints their mount points (argument 2 in the I " "file). B then runs the specified program, B(8), and " "passes it the list of VFAT mountpoints. This unmounts all VFAT partitions." msgstr "" #. type: Plain text #: ../fstab-decode.8:65 #, no-wrap msgid "B\n" msgstr "" #. type: Plain text #: ../fstab-decode.8:68 msgid "B(5)" msgstr "B(5)" #. type: TH #: ../halt.8:20 #, no-wrap msgid "HALT" msgstr "HALT" #. type: TH #: ../halt.8:20 #, no-wrap msgid "Nov 6, 2001" msgstr "6 listopada 2001" #. }}} #. {{{ Synopsis #. type: Plain text #: ../halt.8:27 #, fuzzy #| msgid "halt, poweroff, reboot - Halt, power-off or reboot the machine" msgid "halt, reboot, poweroff - stop the system" msgstr "halt, poweroff, reboot - zatrzymuje, wyłącza lub przeładowuje komputer" #. type: Plain text #: ../halt.8:36 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-p>] [B<-h>]" msgstr "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-p>] [B<-h>]" #. type: Plain text #: ../halt.8:43 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>]" msgstr "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>]" #. }}} #. {{{ Description #. type: Plain text #: ../halt.8:53 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-h>]" msgstr "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-h>]" #. type: Plain text #: ../halt.8:57 msgid "" "B notes that the system is being brought down in the file I, and then either tells the kernel to halt, reboot or power-off the " "system." msgstr "" #. type: Plain text #: ../halt.8:63 msgid "" "If B or B is called when the system is I in runlevel B<0> " "or B<6>, in other words when it's running normally, B will be " "invoked instead (with the B<-h> or B<-r> flag). For more info see the " "B(8) manpage." msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../halt.8:68 msgid "" "The rest of this manpage describes the behavior in runlevels 0 and 6, that " "is when the systems shutdown scripts are being run." msgstr "" #. type: IP #: ../halt.8:69 ../pidof.8:51 ../shutdown.8:95 ../wall.1:53 #, no-wrap msgid "B<-n>" msgstr "B<-n>" #. type: Plain text #: ../halt.8:72 msgid "" "Don't sync before reboot or halt. Note that the kernel and storage drivers " "may still sync. This implies B<-d>." msgstr "" #. type: IP #: ../halt.8:72 ../last.1:102 #, no-wrap msgid "B<-w>" msgstr "B<-w>" #. type: Plain text #: ../halt.8:75 msgid "" "Don't actually reboot or halt but only write the wtmp record (in the I file)." msgstr "" #. type: Plain text #: ../halt.8:77 #, fuzzy #| msgid "Do not write wtmp shutdown entry\\&." msgid "Don't write the wtmp record." msgstr "Nie dokonuje wpisu wtmp\\&." #. type: IP #: ../halt.8:77 ../shutdown.8:87 ../utmpdump.1:29 #, no-wrap msgid "B<-f>" msgstr "B<-f>" #. type: Plain text #: ../halt.8:79 msgid "Force halt or reboot, don't call B(8)." msgstr "" #. type: IP #: ../halt.8:79 ../last.1:93 #, no-wrap msgid "B<-i>" msgstr "B<-i>" #. type: Plain text #: ../halt.8:83 msgid "" "Shut down all network interfaces just before B or B. Warning: " "This may not work on interfaces which do not have an IP address and should " "ideally be handled by a network manager service." msgstr "" #. type: IP #: ../halt.8:83 ../readbootlog.1:45 ../shutdown.8:68 ../utmpdump.1:35 #, no-wrap msgid "B<-h>" msgstr "B<-h>" #. type: Plain text #: ../halt.8:85 msgid "" "Put all hard drives on the system in stand-by mode just before halt or power-" "off." msgstr "" #. type: IP #: ../halt.8:85 ../mountpoint.1:38 #, no-wrap msgid "B<-p>" msgstr "B<-p>" #. }}} #. {{{ Diagnostics #. type: Plain text #: ../halt.8:90 msgid "" "When halting the system, switch off the power. This is the default when " "B is called as B." msgstr "" #. type: SH #: ../halt.8:90 ../init.8:327 #, no-wrap msgid "DIAGNOSTICS" msgstr "DIAGNOSTYKA" #. }}} #. {{{ Notes #. type: Plain text #: ../halt.8:94 msgid "" "If you're not the superuser, you will get the message `must be superuser'." msgstr "" #. type: Plain text #: ../halt.8:103 msgid "" "Under older B releases, B and B should never be " "called directly. From release 2.74 on B and B invoke " "B(8) if the system is not in runlevel 0 or 6. This means that if " "B or B cannot find out the current runlevel (for example, when " "I hasn't been initialized correctly and I " "does not exist) B will be called, which might not be what you " "want. Use the B<-f> flag if you want to do a hard B or B." msgstr "" #. type: Plain text #: ../halt.8:109 msgid "" "The B<-h> flag puts all hard disks in standby mode just before halt or power-" "off. Right now this is only implemented for IDE drives. A side effect of " "putting the drive in stand-by mode is that the write cache on the disk is " "flushed. This is important for IDE drives, since the kernel doesn't flush " "the write cache itself before power-off." msgstr "" #. type: Plain text #: ../halt.8:113 msgid "" "The B program uses I to find all IDE disk devices, " "which means that I needs to be mounted when B or B is " "called or the B<-h> switch will do nothing." msgstr "" #. type: Plain text #: ../halt.8:124 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../init.8:20 #, no-wrap msgid "INIT" msgstr "INIT" #. type: TH #: ../init.8:20 #, no-wrap msgid "29 Jul 2004" msgstr "29 lipca 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../init.8:27 msgid "init, telinit - process control initialization" msgstr "init, telinit - sterowanie procesu inicjującego" #. type: Plain text #: ../init.8:34 msgid "" "B [B< -a >] [B< -s >] [B< -b >] [ B<-z> I ] [B< 0123456Ss >]" msgstr "" "B [B< -a >] [B< -s >] [B< -b >] [B< -z> I] [B< 0123456Ss >]" #. type: Plain text #: ../init.8:37 msgid "B [B< --version >]" msgstr "B [B< --version >]" #. type: Plain text #: ../init.8:41 msgid "B [ B<-t> I ] [B< 0123456sSQqabcUu >]" msgstr "B [B< -t> I ] [B< 0123456sSQqabcUu >]" #. }}} #. {{{ Description #. type: Plain text #: ../init.8:46 msgid "B [ B<-e> I[B<=>I] ]" msgstr "B [B< -e> I[B<=>I] ]" #. {{{ init #. type: SS #: ../init.8:48 #, no-wrap msgid "Init" msgstr "Init" #. type: Plain text #: ../init.8:55 msgid "" "B is the parent of all processes. Its primary role is to create " "processes from a script stored in the file I (see " "B(5)). This file usually has entries which cause B to spawn " "Bs on each line that users can log in. It also controls autonomous " "processes required by any particular system." msgstr "" "B jest przodkiem wszystkich procesów. Jego głównym zadaniem jest " "stworzenie procesów w oparciu o skrypt zapisany w pliku I " "(patrz też B(5)). Ten plik zawiera zwykle pozycje, które każą " "procesowi B pomnażać B na każdej linii, na które użytkownicy " "mogą się zalogować. Kontroluje też samodzielne procesy, których istnienie " "jest konieczne w danym systemie." #. {{{ Runlevels #. type: SH #: ../init.8:57 #, no-wrap msgid "RUNLEVELS" msgstr "POZIOMY PRACY" #. type: Plain text #: ../init.8:66 msgid "" "A I is a software configuration of the system which allows only a " "selected group of processes to exist. The processes spawned by B for " "each of these runlevels are defined in the I file. B " "can be in one of eight runlevels: B<0\\(en6> and B (a.k.a. B). The " "runlevel is changed by having a privileged user run B, which sends " "appropriate signals to B, telling it which runlevel to change to." msgstr "" "I (poziom pracy) jest to konfiguracja oprogramowania systemu, " "która pozwala zaistnieć tylko wytypowanym grupom procesów. Procesy tworzone " "przez B dla każdego z tych poziomów są zdefiniowane w pliku I. B może być w jednym z ośmiu poziomów pracy: B<0\\(en6> i " "B (inaczej B). Poziom pracy jest zmieniany przez uruchomienie " "B przez uprzywilejowanego użytkownika. B wysyła " "odpowiednie sygnały do B, mówiące, w jaki tryb ma przejść." #. type: Plain text #: ../init.8:75 msgid "" "Runlevels B, B<0>, B<1>, and B<6> are reserved. Runlevel S is used to " "initialize the system on boot. When starting runlevel S (on boot) or " "runlevel 1 (switching from a multi-user runlevel) the system is entering " "``single-user mode'', after which the current runlevel is S. Runlevel 0 is " "used to halt the system; runlevel 6 is used to reboot the system." msgstr "" "Tryby pracy B, B<0>, B<1>, oraz B<6> są zarezerwowane. Tryb S jest " "używany do zainicjowania systemu, podczas jego rozruchu. Gdy uruchamiany " "jest tryb pracy S (w czasie rozruchu) lub tryb pracy 1 (przełączanie się z " "trybu wielu użytkowników), system jest wprowadzany w tryb pracy jednego " "użytkownika (\"single-user mode\"), po którym bieżącym poziomem pracy jest " "S. Tryb 0 jest używany, by zatrzymać system; tryb 6, by przeładować system " "(reboot)." #. type: Plain text #: ../init.8:82 msgid "" "After booting through S the system automatically enters one of the multi-" "user runlevels 2 through 5, unless there was some problem that needs to be " "fixed by the administrator in single-user mode. Normally after entering " "single-user mode the administrator performs maintenance and then reboots the " "system." msgstr "" "Po zakończeniu rozruchu w poziomie S, system jest automatycznie wprowadzany " "w jeden z trybów wielu użytkowników, od 2 do 5, chyba że wystąpił problem, " "który musi zostać naprawiony przez administratora, w trybie jednego " "użytkownika. Po przejściu w tryb jednego użytkownika administrator zwykle " "zajmuje się konserwacją, a następnie przeładowuje system." #. type: Plain text #: ../init.8:85 msgid "" "For more information, see the manpages for B(8) and B(5)." msgstr "" "Aby uzyskać więcej informacji na ten temat, proszę zapoznać się ze stronami " "podręcznika B(8) i B(5)." #. type: Plain text #: ../init.8:88 msgid "" "Runlevels 7-9 are also valid, though not really documented. This is because " "\"traditional\" Unix variants don't use them." msgstr "" "Tryby pracy 7-9 również są poprawne, choć niezbyt dobrze udokumentowane. " "Wynika to z faktu, że \"tradycyjne\" warianty Uniksa nie używają ich." #. }}} #. type: Plain text #: ../init.8:92 msgid "" "Runlevels I and I are the same. Internally they are aliases for the " "same runlevel." msgstr "" "Poziomy I i I są w rzeczywistości takie same. Wewnętrznie są to tylko " "zastępcze nazwy dla tego samego trybu pracy." #. type: SH #: ../init.8:93 #, no-wrap msgid "BOOTING" msgstr "ROZRUCH" #. type: Plain text #: ../init.8:100 msgid "" "After B is invoked as the last step of the kernel boot sequence, it " "looks for the file I to see if there is an entry of the type " "B (see B(5)). The B entry determines the " "initial runlevel of the system. If there is no such entry (or no I at all), a runlevel must be entered at the system console." msgstr "" "Po tym jak B jest wywołany w ostatnim kroku sekwencji rozruchowej " "jądra, szuka pliku I w celu znalezienia w nim pola typu " "B (patrz też B(5)). Pole B określa " "początkowy poziom pracy systemu. Jeśli nie ma tam takiego pola (lub wcale " "nie istnieje I), poziom pracy musi być podany z konsoli " "systemowej." #. type: Plain text #: ../init.8:103 msgid "" "Runlevel B or B initialize the system and do not require an I file." msgstr "" "Poziom B lub B wprowadza system w tryb jednego użytkownika i nie " "wymaga pliku I." #. type: Plain text #: ../init.8:105 msgid "In single user mode, B is invoked on I." msgstr "" "W trybie jednego użytkownika, wywoływany jest B na urządzeniu " "I." #. type: Plain text #: ../init.8:109 msgid "" "When entering single user mode, B initializes the consoles B " "settings to sane values. Clocal mode is set. Hardware speed and handshaking " "are not changed." msgstr "" "Podczas wchodzenia w tryb jednego użytkownika, proces B inicjuje " "ustawienia B konsoli na bezpieczne wartości. Ustawiany jest tryb " "clocal. Prędkość sprzętu i handshaking nie są zmieniane." #. type: Plain text #: ../init.8:114 msgid "" "When entering a multi-user mode for the first time, B performs the " "B and B entries to allow file systems to be mounted before " "users can log in. Then all entries matching the runlevel are processed." msgstr "" "Podczas wchodzenia w tryb wielu użytkowników po raz pierwszy, B " "wykonuje pozycje B i B, by pozwolić systemom plików " "zamontować się zanim użytkownicy będą mogli się zalogować. Potem wykonywane " "są wszystkie pozycje przypisane danemu poziomowi pracy." #. type: Plain text #: ../init.8:118 msgid "" "When starting a new process, B first checks whether the file I exists. If it does, it uses this script to start the process." msgstr "" "Kiedy nowy proces startuje, B sprawdza najpierw, czy istnieje plik I. Jeśli tak, używa tego skryptu by ten proces zacząć." #. type: Plain text #: ../init.8:122 msgid "" "Each time a child terminates, B records the fact and the reason it " "died in I and I, provided that these files " "exist." msgstr "" "Za każdym razem, gdy proces potomny się zakończy, B zapamiętuje ten " "fakt i powód śmierci procesu jest zapisany w I i I, pod warunkiem, że te pliki istnieją." #. type: SH #: ../init.8:122 #, no-wrap msgid "CHANGING RUNLEVELS" msgstr "ZMIENIANIE TRYBÓW PRACY" #. type: Plain text #: ../init.8:132 #, fuzzy #| msgid "" #| "After it has spawned all of the processes specified, B waits for " #| "one of its descendant processes to die, a powerfail signal, or until it " #| "is signaled by B to change the system's runlevel. When one of " #| "the above three conditions occurs, it re-examines the B " #| "file. New entries can be added to this file at any time. However, " #| "B still waits for one of the above three conditions to occur. To " #| "provide for an instantaneous response, the B or B command " #| "can wake up B to re-examine the B file." msgid "" "After it has spawned all of the processes specified, B waits for one " "of its descendant processes to die, a powerfail signal, or until it is " "signaled by B to change the system's runlevel. When one of the " "above three conditions occurs, it re-examines the I file. New " "entries can be added to this file at any time. However, B still waits " "for one of the above three conditions to occur. To provide for an " "instantaneous response, the B or B command can wake up B " "to re-examine (reload) the I file." msgstr "" "Po tym jak \"namnożone\" zostaną wszystkie wyszczególnione procesy, B " "czeka na śmierć każdego swojego procesu potomnego, sygnał braku energii lub " "zasygnalizowanie przez B zmiany poziomu działania systemu. Gdy " "wystąpi jeden spośród tych trzech warunków, ponownie sprawdzany jest plik B, ponieważ nowe pola mogą być do niego dodane w każdej chwili. " "Jednakowoż, B wciąż oczekuje na wystąpienie jednego z tych trzech " "warunków. By przygotować się na natychmiastową odpowiedź, B albo " "użyta komenda B może obudzić proces B, by jeszcze raz przeczytał " "plik B." #. type: Plain text #: ../init.8:136 msgid "" "If B is not in single user mode and receives a powerfail signal " "(SIGPWR), it reads the file I. It then starts a command " "based on the contents of this file:" msgstr "" "Jeśli B nie jest w trybie jednego użytkownika i odbiera sygnał zaniku " "energii (SIGPWR), czyta plik I. Następnie uruchamia " "polecenie zależne od zawartości tego pliku:" #. type: IP #: ../init.8:136 #, no-wrap msgid "F(AIL)" msgstr "F(AIL)" #. type: Plain text #: ../init.8:139 msgid "" "Power is failing, UPS is providing the power. Execute the B and " "B entries." msgstr "" "Zawodzi zasilanie, UPS dostarcza mocy. Wykonuje wpisy B i " "B." #. type: IP #: ../init.8:139 #, no-wrap msgid "O(K)" msgstr "O(K)" #. type: Plain text #: ../init.8:141 msgid "The power has been restored, execute the B entries." msgstr "Zasilanie powróciło, uruchamia wpisy B." #. type: IP #: ../init.8:141 #, no-wrap msgid "L(OW)" msgstr "L(OW)" #. type: Plain text #: ../init.8:144 msgid "" "The power is failing and the UPS has a low battery. Execute the " "B entries." msgstr "" "Zasilanie zawodzi, a UPS-owi wyczerpuje się bateria. Wykonuje wpisy " "B." #. type: Plain text #: ../init.8:148 msgid "" "If I doesn't exist or contains anything else then the " "letters B, B or B, B will behave as if it has read the letter " "B." msgstr "" "Jeżeli plik I nie istnieje lub zawiera cokolwiek innego " "niż jedną z liter B, B lub B, B zachowa się tak, jakby " "przeczytał B." #. type: Plain text #: ../init.8:153 #, fuzzy #| msgid "" #| "Usage of B and B is discouraged. Someone " #| "wanting to interact with B should use the B control " #| "channel - see the source code of the B package for more " #| "documentation about this." msgid "" "Usage of B and I is discouraged. Someone wanting " "to interact with B should use the I control channel - " "see the B(5) manual page for more documentation about this." msgstr "" "Używanie B i B nie jest zalecane. Jeżeli ktoś chce " "współdziałać z Bem, powinien użyć kanału kontroli B - " "proszę przeczytać kod źródłowy pakietu B po więcej dokumentacji " "dotyczącej tego kanału." #. }}} #. {{{ telinit #. type: Plain text #: ../init.8:165 msgid "" "When B is requested to change the runlevel, it sends the warning " "signal B to all processes that are undefined in the new runlevel. " "It then waits 3 seconds before forcibly terminating these processes via the " "B signal. Note that B assumes that all these processes (and " "their descendants) remain in the same process group which B originally " "created for them. If any process changes its process group affiliation it " "will not receive these signals. Such processes need to be terminated " "separately." msgstr "" "Gdy B jest proszony o zmianę poziomu działania, wysyła sygnał " "ostrzegawczy B do wszystkich procesów, które nie są zdefiniowane w " "nowym poziomie pracy. Potem czeka 5 sekund zanim \"na siłę\" zakończy te " "procesy poprzez sygnał B. Zauważ, że B zakłada, że wszystkie " "te procesy (i ich potomki) pozostają w tej samej grupie procesów, którą " "B oryginalnie im utworzył. Jeżeli jakikolwiek proces zmienił swą " "przynależność do grupy procesów to nie odbierze tych sygnałów. Tego typu " "procesy muszą być kończone osobno (np. demony wszelakie - przyp. tłum.)." #. type: SH #: ../init.8:165 #, no-wrap msgid "TELINIT" msgstr "TELINIT" #. type: Plain text #: ../init.8:170 msgid "" "B is linked to B. It takes a one-character " "argument and signals B to perform the appropriate action. The " "following arguments serve as directives to B:" msgstr "" "B jest symbolicznym dowiązaniem do B. Pobiera on " "jednoznakowy argument i sygnały B, by podjął stosowne działanie. " "Poniższe argumenty można stosować jako rozkazy dla B:" #. type: IP #: ../init.8:170 #, no-wrap msgid "B<0>, B<1>, B<2>, B<3>, B<4>, B<5> or B<6>" msgstr "B<0>, B<1>, B<2>, B<3>, B<4>, B<5> lub B<6>" #. type: Plain text #: ../init.8:172 msgid "tell B to switch to the specified run level." msgstr "mówią procesowi B by przełączył w odpowiedni poziom działania." #. type: IP #: ../init.8:172 #, fuzzy, no-wrap #| msgid "B,B,B" msgid "B, B, B" msgstr "B,B,B" #. type: Plain text #: ../init.8:175 #, fuzzy #| msgid "" #| "tell B to process only those B file entries having " #| "runlevel B,B or B." msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" "każą procesowi B by przetwarzał tylko te pola pliku B, " "które odnoszą się do poziomu pracy B,B lub B." #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "B lub B" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "każą procesowi B jeszcze raz przeczytać plik I." #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "B lub B" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "mówią żeby B przełączył w tryb jednego użytkownika." #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "B lub B" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" "każą procesowi B przeładować się (zachowując obecny stan). Nie " "występuje ponowne odczytywanie pliku I. Poziom pracy powinien " "być ustawiony na B, w przeciwnym wypadku żądanie może być " "\"delikatnie\" zignorowane." #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" "B może także powiedzieć procesowi B, jak długo powinien on " "czekać między wysyłaniem sygnałów B i B. Domyślną " "wartością jest 3 sekund, ale może być ona zmieniona za pomocą opcji B<-t>." #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" "B mówi procesowi B, aby zmienił środowisko procesów, które " "mnoży. Argumenty do B<-e> mogą mieć postać I=I, która " "ustawia zmiennej I wartość I lub postać I (bez " "znaku równości), która usuwa zmienną I." #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" "B może być wywoływany tylko przez użytkowników uprzywilejowanych." #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" "Wywołany B sprawdza czy jest procesem inicjującym B czy też jest " "wywołany jako B poprzez wgląd w swój I; " "prawdziwy identyfikator procesu B ma zawsze wartość B<1>. Teraz już " "wiadomo, że zamiast wywoływać B możesz też po prostu użyć B, " "a nie skrótu." #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "ŚRODOWISKO" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "" "B ustawia następujące zmienne środowiskowe dla wszystkich swoich " "dzieci:" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "I" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" "Jak mówi nazwa - wersja programu. Użyteczne dla określenia, jeśli skrypt " "uruchamia się bezpośrednio z B." #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "Obecny poziom pracy systemu." #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "Poprzedni poziom pracy systemu (użyteczne po zmianie poziomów)." #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" "Konsola systemu. Tak naprawdę ta wartość jest przyjmowana od jądra; jednak " "jeśli nie jest ustawiona B ustawi ją domyślnie na I." #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "FLAGI STARTOWE" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" "Jest możliwe by przekazać pewne flagi do procesu B z monitora " "startowego (np. LILO lub GRUB). B dopuszcza stosowanie następujących " "flag:" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "B<-s, S, single>" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" "Rozruch w trybie jednego użytkownika. W tym trybie I jest " "sprawdzany (wczytywany) i skrypty startowe rc są zwykle uruchamiane zanim " "wystartuje powłoka dla trybu jednego użytkownika." #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "B<1-5>" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "Poziom działania w jakim system ma wystartować." #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "B<-b, emergency>" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" "Wejście bezpośrednio w tryb jednego użytkownika bez uruchamiania żadnych " "innych skryptów startowych." #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "B<-a, auto>" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" "Program ładujący LILO dodaje słowo \"auto\" do linii poleceń, jeżeli " "uruchomił jądro z domyślną linią poleceń (użytkownik jej nie zmieniał). " "Jeżeli B znajdzie to słowo, ustawi zmienną środowiskową \"AUTOBOOT\" " "na \"yes\". Proszę zauważyć, że nie można tego użyć jako środka " "bezpieczeństwa - oczywiści użytkownik mógł ręcznie w linii poleceń wpisać " "\"auto\" użyć opcji B<-a>." #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "B<-z >I" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" "Argument opcji B<-z> jest ignorowany. Może być użyta do wydłużenia linii " "poleceń, tak żeby zajmowała więcej miejsca na stosie. B może wtedy " "manipulować linią poleceń, tak żeby B(1) pokazywało bieżący tryb " "uruchomienia." #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "INTERFEJS" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" "B nasłuchuje wiadomości na łączu I w /dev, I. " "B używa tego do komunikacji z procesem init. Ten interfejs nie jest " "zbyt dobrze udokumentowany czy skończony. Zainteresowani powinni " "przestudiować plik I w podkatalogu I archiwum tarowego z " "kodem źródłowym B." #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "SYGNAŁY" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "Init reaguje na następujące sygnały:" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "Ma ten sam efekt co B." #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:276 #, fuzzy #| msgid "" #| "On receipt of this signals, init closes and re-opens its control fifo, B." msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" "Po odebraniu tego sygnału, init zamyka i ponownie otwiera swoją kontrolkę " "fifo, B." #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:287 #, fuzzy #| msgid "" #| "Normally the kernel sends this signal to init when CTRL-ALT-DEL is " #| "pressed. It activates the I action." msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" "Zwykle ten sygnał jest wysyłany z jądra by powiedzieć, że wciśnięta została " "kombinacja klawiszy CTRL-ALT-DEL. Powoduje to rozpoczęcie akcji " "I." #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" "Jądro wysyła ten sygnał jeśli wciśnięty został klawisz I. " "Aktywuje to akcję I." #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "ZGODNE Z" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" "B jest kompatybilny z init obecnym System V. Działa razem ze skryptami " "w katalogach I i I. Jeśli twój " "system używa tej konwencji, to powinien być obecny plik I w katalogu " "I wyjaśniający, jak te skrypty działają." #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "PLIKI" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "OSTRZEŻENIA" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" "B zakłada, że procesy i ich procesy potomne pozostają w tej samej " "grupie procesów, która była dla nich oryginalnie stworzona. Jeżeli " "jakikolwiek proces zmienił swą przynależność do grupy procesów, B nie " "może ich zabić i może skończyć się na tym, że zostaną dwa procesy czytające " "z jednego wiersza terminala." #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" "W systemie Debian, wejście w poziom pracy 1 powoduje zabicie wszystkich " "procesów z wyjątkiem wątków jądra i skryptu który wykonuje zabijanie oraz " "innych procesów w jego sesji. W konsekwencji, powracanie z poziomu 1 do " "poziomu pracy trybu wielu użytkowników nie jest bezpieczne: demony, które " "zostały uruchomione w poziomie S i są wymagane do normalnego działania nie " "są dłużej uruchomione. System powinien zostać uruchomiony ponownie." #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" "Jeśli B zorientuje się, że wciąż powtarza namnażanie zadanego procesu " "częściej niż 10 razy w ciągu 2 minut, wtedy założy, że gdzieś w wywołaniu " "komendy jest błąd, wyśle wiadomość o błędzie na konsolę systemu, i przerwie " "pomnażanie danego pola do upłynięcia 5 minut lub do odebrania sygnału. " "Zapobiega to \"zjadaniu\" zasobów systemu gdy ktoś popełni literówkę w pliku " "I lub gdy program normalnie uruchamiany dla danego wpisu jest " "usunięty." #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>, pierwszą " "wersję strony podręcznika napisał E<.MT u31b3hs@\\:pool\\:.informatik\\:." "rwth-aachen\\:.de> Michael Haardt E<.ME .>" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "INITCTL" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "13 kwietnia 2018" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "/run/initctl" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 #, fuzzy #| msgid "The previous runlevel (useful after a runlevel switch)." msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "Poprzedni poziom pracy systemu (użyteczne po zmianie poziomów)." #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "/run/initctl /sbin/init" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "INITSCRIPT" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "10 lipca 2003" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "initscript - skrypt wykonujący polecenia zawarte w inittab" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "/bin/sh /etc/initscript id poziom działanie proces" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" "Jeśli w systemie znajduje się skrypt I, B spróbuje " "nim wykonać polecenia zawarte w I. Można go wykorzystać np. do " "ustawienia domyślnych wartości I i I dla każdego procesu." #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" "Poniżej znajduje się przykładowy skrypt startowy, który mógł zostać " "zainstalowany w systemie jako I." #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" "#\n" "# initscript Wykonywany przez init(8) dla każdego wywołanego \n" "# przez niego programu w ten sposób:\n" "#\n" "#\t/bin/sh /etc/initscript EidE EpoziomE EdziałanieE EprocesE\n" "#\n" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" " # Ustawiamy bezpieczną wartość umask i ustawiamy zrzuty rdzenia:\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" " # Zwiększamy twardy limit deskryptora pliku dla wszystkich \n" " # procesów do 8192. Miękki limit wciąż wynosi 1024, jednak każdy\n" " # nieuprzywilejowany proces może zwiększyć swój miękki limit aż do\n" " # wartości twardego limitu za pomocą \"ulimit -Sn xxx\"\n" " # (niezbędne jest jądro 2.2.13 lub nowsze)\n" " ulimit -Hn 8192\n" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" " # Wykonujemy program.\n" " eval exec \"$4\"\n" #. type: Plain text #: ../initscript.5:65 #, fuzzy #| msgid "" #| "This script is not meant as startup script for daemons or somesuch. It " #| "has nothing to do with a I style script. It's just a handler " #| "for things executed from B. Experimenting with this can " #| "make your system un(re)bootable." msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" "Skrypt nie jest zaprojektowany jako skrypt startowy dla demonów itp. Nie ma " "on nic wspólnego ze skryptami w stylu I. Jest to po prostu skrypt " "obsługujący rzeczy wykonywane z B. Własne eksperymentowanie z " "opisywanym skryptem może spowodować problemy z (ponownym) uruchomieniem " "systemu." #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "/etc/inittab, /etc/initscript." #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "B(5), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "4 grudnia 2001" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" "inittab - format pliku inittab używanego przez proces init, kompatybilny z " "sysv" #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" "Plik B opisuje które procesy zostały uruchomione podczas startu i " "podczas normalnego działania (np. /etc/init.d/boot, /etc/init.d/rc, " "getty...). B(8) rozróżnia różne I, z których każdy może " "mieć swój własny zestaw procesów uruchamianych na starcie. Dopuszczalne " "poziomy pracy to B<0>-B<6> i B, B i B dla wpisów B (na " "żądanie). Wpis w pliku inittab ma następujący format:" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "I:I:I:I" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "Linie rozpoczynające się od \"#\" są ignorowane." #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:48 msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" "jest unikalną sekwencją 1-4 znaków, która identyfikuje wpis w B " "(dla wersji sysvinit skompilowanych ze I biblioteką libc5 (E " "5.2.18 lub z bibliotekami a.out, jego długość może być ograniczona do dwóch " "znaków)." #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" "Uwaga: Dla procesów getty, lub innych procesów loginowych, pole I " "powinno być końcówką odpowiadającego im tty, np. B<1> dla B. Część " "bardzo starych programów login może oczekiwać takiej konwencji, choć trudno " "podać w tej chwili jakiś przykład." #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "opisują, w których poziomach pracy podjąć podaną akcję." #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "opisuje jaką akcję podjąć." #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:70 msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" "podaje proces, który należy uruchomić. Jeśli pole procesu rozpoczyna się " "znakiem \"+\", init nie dokona dla niego wpisów wtmp i utmp. Jest to " "wymagane dla getty, które wolą robić to samodzielnie. Jest to też błąd " "historyczny. Ograniczenie długości tego pola wynosi 127 znaków." #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" "Pole I może zawierać wiele znaków dla różnych poziomów. Na " "przykład, B<123> określa, że proces powinien być uruchamiany w poziomach " "pracy 1, 2 i 3. I do wpisów B mogą zawierać B, " "B lub B. Pole to jest ignorowane w przypadku następujących wpisów: " "B, B i B." #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" "Gdy poziom pracy jest zmieniany, zabijane są wszystkie procesy, które nie są " "podane w nowym poziomie pracy, zaczynając od sygnału \\s-2SIGTERM\\s0, a " "następnie \\s-2SIGKILL\\s0." #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "Dopuszczalne akcje w polu I to:" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "" "Proces będzie uruchomiony od nowa po każdym jego zakończeniu (np. getty)." #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" "Proces będzie uruchomiony raz (gdy nadejdzie właściwy poziom pracy), a " "B będzie czekał na jego zakończenie." #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "Proces będzie wywołany raz po wejściu we właściwy poziom pracy." #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" "Proces zostanie wywołany podczas rozruchu. Pole I jest " "ignorowane." #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" "Proces zostanie wywołany podczas rozruchu, podczas gdy init czeka na jego " "zakończenie (np. /etc/rc). Pole I jest ignorowane." #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "Nie robi nic." #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" "Proces, który jest zaznaczony poziomem pracy B będzie wywoływany " "za każdym razem, gdy zostanie wywołany wskazany poziom żądania. Mimo to " "jednak, nie nastąpi zmiana poziomu pracy (poziomy pracy B to \"a" "\", \"b\", \"c\")." #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" "Pole to określa poziom pracy, który powinien być uruchomiony po procesie " "rozruchu. Jeśli żaden taki nie istnieje, init zapyta o poziom pracy na " "konsoli. Pole I jest ignorowane." #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" "Proces zostanie wywołany podczas rozruchu. Zostanie wywołany przed wszelkimi " "wpisami B czy B< bootwait>. Pole I jest ignorowane." #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" "Proces zostanie wywołany w czasie problemów z zasilaniem. B jest z " "reguły informowany o takim zdarzeniu przez proces porozumiewający się z " "podłączonym do komputera UPS-em. B będzie czekał na zakończenie tego " "procesu przed dalszą kontynuacją." #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" "Podobne do B, lecz init nie będzie czekał na zakończenie tego " "procesu." #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" "Proces zostanie wywołany, gdy B otrzyma sygnał, że zasilanie zostało " "przywrócone." #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" "Proces zostanie wykonany, gdy B dowie się o krytycznym poziomie " "baterii zewnętrznego UPS-a i o właśnie zawodzącym zasilaniu (jeśli " "zewnętrzny UPS i monitorujący go proces są w stanie wykryć taki stan)." #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" "Proces zostanie wykonany gdy B otrzyma sygnał B. Znaczy to, " "że ktoś na konsoli nacisnął kombinację B. Zazwyczaj wywołuje " "się wtedy coś w rodzaju B, zarówno w celu przejścia do poziomu " "jednoużytkownikowego, jak i do ponownego uruchomienia komputera." #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" "Proces zostanie wywołany gdy B otrzyma sygnał z sterownika klawiatury, " "mówiący że na konsoli została naciśnięta specjalna kombinacja klawiszy." #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" "Dokumentacja tej funkcji nie jest jeszcze kompletna; więcej danych można " "znaleźć w pakietach kbd-x.xx (w chwili powstania tego tekstu było to " "kbd-0.94). Ogólnie, można mapować niektóre kombinacje klawiszy do akcji " "\"KeyboardSignal\". Na przykład, aby zmapować na ten cel kombinację alt plus " "strzałka w górę, należy użyć następującego wpisu w swoim pliku keymap:" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "alt keycode 103 = KeyboardSignal" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "Oto przykład inittab, który zawiera stary inittab Linuksa:" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" "# inittab do Linuksa\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" #. type: Plain text #: ../inittab.5:222 msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" "Ten plik inittab wywołuje I podczas rozruchu i uruchamia getty dla " "tty1-tty4." #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" "Bardziej wykwintny inittab, z różnymi poziomami pracy (patrz komentarze):" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" "# Poziom, w którym startować\n" "id:2:initdefault:\n" #. type: Plain text #: ../inittab.5:234 #, no-wrap msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" "# Skrypt inicjujący/konfigurujący system w czasie rozruchu.\n" "si::sysinit:/etc/init.d/rcS\n" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" "# Co robić w trybie jednoużytkownikowym.\n" "~:S:wait:/sbin/sulogin\n" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" "# /etc/init.d wykonuje skrypty S i K w trakcie\n" "# zmiany poziomu pracy.\n" "#\n" "# Poziom pracy 0 oznacza zatrzymanie.\n" "# Poziom pracy 1 jest jednoużytkownikowy.\n" "# Poziomy pracy 2-5 są wieloużytkownikowe.\n" "# Poziom pracy 6 oznacza ponowne uruchomienie.\n" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" "# Co zrobić przy ctrl+alt+del.\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" #. type: Plain text #: ../inittab.5:265 #, no-wrap msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" "# Poziomy 2 i 3: getty na konsolach wirtualnych\n" "# Poziom 3: getty na terminalu (ttyS0) i modemie (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 #, fuzzy #| msgid "" #| "B was written by Miquel van Smoorenburg (miquels@cistron.nl). This " #| "manual page was written by Sebastian Lederer (lederer@francium.informatik." #| "uni-bonn.de) and modified by Michael Haardt (u31b3hs@pool.informatik.rwth-" #| "aachen.de)." msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "Init został napisany przez Miquela van Smoorenburga (miquels@cistron.nl), " "strona podręcznika została napisana przez Sebastiana Lederera " "(lederer@francium.informatik.uni-bonn.de) i zmodyfikowana przez Michaela " "Haardta (u31b3hs@pool.informatik.rwth-aachen.de)." #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "KILLALL5" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "4 listopada 2003" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "killall5 - wysyła sygnał do wszystkich procesów" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" "B B<-numer-sygnału> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" "B jest poleceniem B z SystemV. Wysyła sygnał do " "wszystkich procesów, poza procesami jądra i procesami swojej sesji, więc nie " "ubije powłoki, w której pracuje skrypt, w którym wywołano tę komendę. " "Podstawowym (jedynym) zastosowaniem polecenia jest użycie w plikach " "startowych B, z katalogu I." #. type: IP #: ../killall5.8:35 #, no-wrap msgid "B<-o> I" msgstr "B<-o> I" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "" "Nakazuje B pomijać procesy o podanym identyfikatorze procesu." #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" "B może zostać wywołany również jako B(8), który jest " "dowiązaniem symbolicznym do programu B." #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" "Program zwraca zero, jeśli istnieje zabity proces. Zwraca 2, gdy nie zabito " "żadnego procesu i 1, gdy nie udało się znaleźć żadnego procesu (brak I)." #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "B(8), B(8), B(8)" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "LAST," #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "1" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "31 lipca 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "last, lastb - pokazuje listę ostatnio zalogowanych użytkowników" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" #. type: Plain text #: ../last.1:56 #, fuzzy #| msgid "" #| "B searches back through the I file (or the file " #| "designated by the B<-f> option) and displays a list of all users logged " #| "in (and out) since that file was created. One or more I and/" #| "or I can be given, in which case B will show only the entries " #| "matching those arguments. Names of I can be abbreviated, thus " #| "B is the same as B." msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" "Program B przeszukuje wstecz plik B (lub plik wskazany " "opcją B<-f>) i wyświetla listę wszystkich zalogowanych (i wylogowanych) od " "czasu utworzenia pliku użytkowników. Można podać jedną lub więcej I i/lub I (terminali); w tym przypadku B pokaże " "jedynie zapisy pasujące do tych argumentów. Nazwy I mogą być skracane, " "zatem B, to to samo, co B." #. type: Plain text #: ../last.1:61 #, fuzzy #| msgid "" #| "When catching a SIGINT signal (generated by the interrupt key, usually " #| "control-C) or a SIGQUIT signal, B will show how far it has searched " #| "through the file; in the case of the SIGINT signal B will then " #| "terminate." msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" "Po przechwyceniu sygnału SIGINT (generowany przez klawisz przerwania, zwykle " "control-C) lub sygnał SIGQUIT, B pokaże jak daleko przeszukał plik; " "następnie, w przypadku sygnału SIGINT, B przerwie pracę." #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "" "Pseudoużytkownik B rejestrowany jest przy każdorazowym przeładowaniu " "systemu. Zatem B pokaże rejestr (log) wszystkich przeładowań od " "utworzenia pliku rejestrującego." #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" "B jest tym samym, co B, z wyjątkiem tego, że domyślnie pokazuje " "zapisy z pliku I, zawierającego zakończone niepowodzeniem " "próby logowań." #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "B<-f> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" #. type: IP #: ../last.1:73 #, no-wrap msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 #, fuzzy #| msgid "Tell B how many lines to show." msgid "This is a count telling B how many lines to show." msgstr "Liczba mówiąca B, ile wierszy ma pokazać." #. type: IP #: ../last.1:75 #, no-wrap msgid "B<-n> I" msgstr "B<-n> I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "" #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "" #. type: Plain text #: ../last.1:82 #, fuzzy #| msgid "" #| "Display the state of logins since the specified I," #~ msgstr "B," #~ msgid "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgstr "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #, fuzzy, no-wrap #~| msgid "LAST, LASTB" #~ msgid "LAST,LASTB" #~ msgstr "LAST, LASTB" #, fuzzy, no-wrap #~| msgid "Linux System Administrator's Manual" #~ msgid "Linux User's Manual" #~ msgstr "Podręcznik administratora systemu Linux" #, fuzzy #~| msgid "Miquel van Smoorenburg, miquels@cistron.nl" #~ msgid "Miquel van Smoorenburg (miquels@cistron.nl)" #~ msgstr "Miquel van Smoorenburg, miquels@cistron.nl" #, no-wrap #~ msgid "-s" #~ msgstr "-s" #, no-wrap #~ msgid "-c" #~ msgstr "B<-c>" #, no-wrap #~ msgid "-n" #~ msgstr "-n" #, no-wrap #~ msgid "-q" #~ msgstr "-q" #, no-wrap #~ msgid "-x" #~ msgstr "-x" #, no-wrap #~ msgid "-z" #~ msgstr "-z" #, fuzzy #~| msgid "" #~| "B looks for the environment variable B or B " #~| "to determine what shell to start. If the environment variable is not " #~| "set, it will try to execute root's shell from I. If that " #~| "fails, it will fall back to I." #~ msgid "" #~ "I looks for the environment variable B or B to " #~ "determine what shell to start. If the environment variable is not set, it " #~ "will try to execute root's shell from /etc/passwd. If that fails it will " #~ "fall back to B." #~ msgstr "" #~ "B szuka zmiennych środowiskowych B lub B, aby " #~ "określić którą powłokę uruchomić. Jeśli zmienna środowiskowa nie jest " #~ "ustawiona, to program spróbuje wykonać powłokę roota z pliku I. Jeśli to również się nie powiedzie, to na końcu wykorzystana " #~ "zostanie powłoka I." #, fuzzy #~| msgid "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #~ msgid "Miquel van Smoorenburg Emiquels@cistron.nlE" #~ msgstr "Miquel van Smoorenburg ,Emiquels@cistron.nlE" #, no-wrap #~ msgid "systemd 249" #~ msgstr "systemd 249" #, no-wrap #~ msgid "halt" #~ msgstr "halt" #~ msgid "B [OPTIONS...]" #~ msgstr "B [I...]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [I...]" #~ msgid "B [OPTIONS...]" #~ msgstr "B [I...]" #~ msgid "" #~ "B, B, B may be used to halt, power-off, or reboot " #~ "the machine\\&. All three commands take the same options\\&." #~ msgstr "" #~ "B, B, B służy do zatrzymania, wyłączenia lub " #~ "przeładowania komputera. Wszystkie trzy polecenia przyjmują te same opcje." #~ msgid "The following options are understood:" #~ msgstr "Obsługiwane są następujące opcje:" #~ msgid "B<--help>" #~ msgstr "B<--help>" #~ msgid "Print a short help text and exit\\&." #~ msgstr "Wyświetla krótki komunikat pomocy i wychodzi\\&." #~ msgid "B<--halt>" #~ msgstr "B<--halt>" #~ msgid "" #~ "Halt the machine, regardless of which one of the three commands is invoked" #~ "\\&." #~ msgstr "" #~ "Zatrzymuje komputer, niezależnie od tego, którego z trzech poleceń użyto" #~ "\\&." #~ msgid "B<-p>, B<--poweroff>" #~ msgstr "B<-p>, B<--poweroff>" #~ msgid "" #~ "Power-off the machine, regardless of which one of the three commands is " #~ "invoked\\&." #~ msgstr "" #~ "Wyłącza komputer, niezależnie od tego, którego z trzech poleceń użyto\\&." #~ msgid "B<--reboot>" #~ msgstr "B<--reboot>" #~ msgid "" #~ "Reboot the machine, regardless of which one of the three commands is " #~ "invoked\\&." #~ msgstr "" #~ "Przeładowuje komputer, niezależnie od tego, którego z trzech poleceń użyto" #~ "\\&." #~ msgid "B<-f>, B<--force>" #~ msgstr "B<-f>, B<--force>" #~ msgid "" #~ "Force immediate halt, power-off, or reboot\\&. When specified once, this " #~ "results in an immediate but clean shutdown by the system manager\\&. When " #~ "specified twice, this results in an immediate shutdown without contacting " #~ "the system manager\\&. See the description of B<--force> in " #~ "B(1) for more details\\&." #~ msgstr "" #~ "Wymusza natychmiastowe zatrzymanie, wyłączenie lub przeładowanie\\&. Przy " #~ "jednokrotnym użyciu opcji, menedżer systemu dokona natychmiastowego, ale " #~ "bezpiecznego wyłączenia. \\&. Dwukrotne podanie opcji spowoduje " #~ "natychmiastowe zamknięcie bez użycia menedżera systemu. \\&. Więcej " #~ "szczegółów znajduje się w opisie opcji B<--force> podręcznika systemowego " #~ "B(1)\\&." #~ msgid "B<-w>, B<--wtmp-only>" #~ msgstr "B<-w>, B<--wtmp-only>" #~ msgid "" #~ "Only write wtmp shutdown entry, do not actually halt, power-off, reboot" #~ "\\&." #~ msgstr "" #~ "Dokonuje jedynie wpisu wtmp , bez rzeczywistego zatrzymania, wyłączenia " #~ "lub przeładowania\\&." #~ msgid "B<-d>, B<--no-wtmp>" #~ msgstr "B<-d>, B<--no-wtmp>" #~ msgid "B<-n>, B<--no-sync>" #~ msgstr "B<-n>, B<--no-sync>" #~ msgid "" #~ "Don\\*(Aqt sync hard disks/storage media before halt, power-off, reboot" #~ "\\&." #~ msgstr "" #~ "Nie wykonuje synchronizacji twardych dysków/nośników danych przed " #~ "zatrzymaniem, wyłączeniem lub przeładowaniem\\&." #~ msgid "B<--no-wall>" #~ msgstr "B<--no-wall>" #~ msgid "Do not send wall message before halt, power-off, reboot\\&." #~ msgstr "" #~ "Nie wysyła komunikatu wall przed zatrzymaniem, wyłączeniem lub " #~ "przeładowaniem\\&." #~ msgid "On success, 0 is returned, a non-zero failure code otherwise\\&." #~ msgstr "" #~ "W przypadku powodzenia zwracane jest 0, w razie błędu kod jest niezerowy" #~ "\\&." #~ msgid "" #~ "These commands are implemented in a way that preserves basic " #~ "compatibility with the original SysV commands\\&. B(1) verbs " #~ "B, B, B provide the same functionality with some " #~ "additional features\\&." #~ msgstr "" #~ "Polecenia zaimplementowano w sposób zapewniający podstawową " #~ "kompatybilność z pierwotnymi poleceniami z SysV\\&. Argumenty B, " #~ "B, B narzędzia B(1) obsługują te same " #~ "funkcje oraz kilka dodatkowych\\&." #~ msgid "" #~ "Note that on many SysV systems B used to be synonymous to " #~ "B, i\\&.e\\&. both commands would equally result in powering " #~ "the machine off\\&. systemd is more accurate here, and B results in " #~ "halting the machine only (leaving power on), and B is required " #~ "to actually power it off\\&." #~ msgstr "" #~ "Proszę zauważyć, że na wielu systemach SysV polecenie B było " #~ "synonimem B, tzn. oba polecenia powodowały wyłączenie komputera" #~ "\\&. W systemd jest to dokładniejsze, B powoduje zatrzymanie " #~ "komputera (z pozostawieniem włączonego zasilania), a do wyłączenia " #~ "komputera należy użyć B\\&." #~ msgid "B(1), B(1), B(8), B(1)" #~ msgstr "B(1), B(1), B(8), B(1)" #, no-wrap #~ msgid "systemd 250" #~ msgstr "systemd 250" #~ msgid "" #~ "This script is not meant as startup script for daemons or somesuch. It " #~ "has nothing to do with a I style script. It's just a handler " #~ "for things executed from B. Experimenting with this can " #~ "make your system un(re)bootable." #~ msgstr "" #~ "Skrypt nie jest zaprojektowany jako skrypt startowy dla demonów itp. Nie " #~ "ma on nic wspólnego ze skryptami w stylu I. Jest to po prostu " #~ "skrypt obsługujący rzeczy wykonywane z B. Własne " #~ "eksperymentowanie z opisywanym skryptem może spowodować problemy z " #~ "(ponownym) uruchomieniem systemu." #, no-wrap #~ msgid "2021-06-02" #~ msgstr "2 czerwca 2021 r." #, no-wrap #~ msgid "util-linux 2.37.2" #~ msgstr "util-linux 2.37.2" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [I] [I...] [I...]" #~ msgid "B [options] [I...] [I...]" #~ msgstr "B [I] [I...] [I...]" #~ msgid "" #~ "B searches back through the I file (or the file " #~ "designated by the B<-f> option) and displays a list of all users logged " #~ "in (and out) since that file was created. One or more I and/or " #~ "I can be given, in which case B will show only the entries " #~ "matching those arguments. Names of I can be abbreviated, thus " #~ "B is the same as B." #~ msgstr "" #~ "Program B przeszukuje wstecz plik B (lub plik " #~ "wskazany opcją B<-f>) i wyświetla listę wszystkich zalogowanych (i " #~ "wylogowanych) od czasu utworzenia pliku użytkowników. Można podać jedną " #~ "lub więcej I i/lub I (terminali); w tym przypadku " #~ "B pokaże jedynie zapisy pasujące do tych argumentów. Nazwy I " #~ "mogą być skracane, zatem B, to to samo, co B." #~ msgid "" #~ "When catching a B signal (generated by the interrupt key, usually " #~ "control-C) or a SIGQUIT signal, B will show how far it has searched " #~ "through the file; in the case of the B signal B will then " #~ "terminate." #~ msgstr "" #~ "Po przechwyceniu sygnału B (generowany przez klawisz przerwania, " #~ "zwykle control-C) lub sygnał B, B pokaże jak daleko " #~ "przeszukał plik; następnie, w przypadku sygnału B, B " #~ "przerwie pracę." #~ msgid "" #~ "The pseudo user B logs in each time the system is rebooted. Thus " #~ "B will show a log of all the reboots since the log file was " #~ "created." #~ msgstr "" #~ "Pseudoużytkownik B rejestrowany jest przy każdorazowym " #~ "przeładowaniu systemu. Zatem B pokaże rejestr (log) " #~ "wszystkich przeładowań od utworzenia pliku rejestrującego." #~ msgid "B<-a>, B<--hostlast>" #~ msgstr "B<-a>, B<--hostlast>" #~ msgid "B<-d>, B<--dns>" #~ msgstr "B<-d>, B<--dns>" #~ msgid "" #~ "Tell B to use a specific I instead of I. The " #~ "B<--file> option can be given multiple times, and all of the specified " #~ "files will be processed." #~ msgstr "" #~ "B użyje podanego I zamiast I. Opcję B<--file> " #~ "można podać wiele razy i przetworzone będą wszystkie podane pliki." #~ msgid "B<-F>, B<--fulltimes>" #~ msgstr "B<-F>, B<--fulltimes>" #~ msgid "B<-i>, B<--ip>" #~ msgstr "B<-i>, B<--ip>" #~ msgid "" #~ "Like B<--dns ,> but displays the host\\(cqs IP number instead of the name." #~ msgstr "Jak B<--dns>, lecz wyświetla numer IP zamiast nazwy komputera." #~ msgid "B<->I; B<-n>, B<--limit> I" #~ msgstr "B<->I; B<-n>, B<--limit> I" #~ msgid "B<-p>, B<--present> I
" #, no-wrap #~ msgid "(time will be set to 00:00:00)" #~ msgstr "(czas będzie ustawiony na 00:00:00)" #, no-wrap #~ msgid "hh:mm:ss" #~ msgstr "IB<:>IB<:>I" #, no-wrap #~ msgid "(date will be set to today)" #~ msgstr "(data będzie ustawiona na dziś)" #, no-wrap #~ msgid "hh:mm" #~ msgstr "IB<:>I" #, no-wrap #~ msgid "(date will be set to today, seconds to 00)" #~ msgstr "(data będzie ustawiona na dziś, sekundy na 00)" #, no-wrap #~ msgid "now" #~ msgstr "B (teraz)" #, no-wrap #~ msgid "yesterday" #~ msgstr "B (wczoraj)" #, no-wrap #~ msgid "(time is set to 00:00:00)" #~ msgstr "(czas jest ustawiany na 00:00:00)" #, no-wrap #~ msgid "today" #~ msgstr "B (dziś)" #, no-wrap #~ msgid "tomorrow" #~ msgstr "B (jutro)" #, no-wrap #~ msgid "+5min" #~ msgstr "B<+5min> (za 5 minut)" #, no-wrap #~ msgid "-5days" #~ msgstr "B<-5days> (5 dni temu)" #~ msgid "I, I" #~ msgstr "I, I" #, no-wrap #~ msgid "AUTHORS" #~ msgstr "AUTORZY" #~ msgid "B(1), B(5), B(8), B(8)" #~ msgstr "B(1), B(5), B(8), B(8)" #, no-wrap #~ msgid "REPORTING BUGS" #~ msgstr "ZGŁASZANIE BŁĘDÓW" #, no-wrap #~ msgid "AVAILABILITY" #~ msgstr "DOSTĘPNOŚĆ" #, no-wrap #~ msgid "October 2013" #~ msgstr "październik 2013" #, no-wrap #~ msgid "util-linux" #~ msgstr "util-linux" #, no-wrap #~ msgid "B<-a>,B< --hostlast>" #~ msgstr "B<-a>,B< --hostlast>" #~ msgid "" #~ "Display the hostname in the last column. Useful in combination with the " #~ "B<--dns> option." #~ msgstr "" #~ "Wyświetla nazwę hosta w ostatniej kolumnie. Przydatne w połączeniu z " #~ "opcją B<--dns>." #, no-wrap #~ msgid "B<-d>,B< --dns>" #~ msgstr "B<-d>,B< --dns>" #~ msgid "" #~ "For non-local logins, Linux stores not only the host name of the remote " #~ "host, but its IP number as well. This option translates the IP number " #~ "back into a hostname." #~ msgstr "" #~ "Dla logowań nie-lokalnych Linux przechowuje nie tylko nazwę zdalnego " #~ "hosta, ale i jego numer IP. Opcja ta przekłada numer IP z powrotem na " #~ "nazwę hosta." #, no-wrap #~ msgid "B<-f>,B< --file >I" #~ msgstr "B<-f>,B< --file >I" #~ msgid "" #~ "Tell B to use a specific I instead of I. The " #~ "B<--file> option can be given multiple times, and all of the specified " #~ "files will be processed." #~ msgstr "" #~ "B użyje podanego I zamiast I. Opcję B<--file> " #~ "można podać wiele razy i przetworzone będą wszystkie podane pliki." #, no-wrap #~ msgid "B<-F>,B< --fulltimes>" #~ msgstr "B<-F>,B< --fulltimes>" #, no-wrap #~ msgid "B<-i>,B< --ip>" #~ msgstr "B<-i>,B< --ip>" #~ msgid "" #~ "Like B<--dns ,> but displays the host's IP number instead of the name." #~ msgstr "Jak B<--dns>, lecz wyświetla numer IP zamiast nazwy komputera." #, no-wrap #~ msgid "B<-n>,B< --limit >I" #~ msgstr "B<-n>,B< --limit >I" #, no-wrap #~ msgid "B<-p>,B< --present >I, B, B" msgstr "B, B, B" #. type: Plain text #: ../init.8:175 #| msgid "" #| "tell B to process only those B file entries having " #| "runlevel B,B or B." msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" "diz ao B para processar apenas aquelas entradas no ficheiro " "B que têm runlevel B,B ou B." #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "B ou B" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "diz ao B para re-examinar o ficheiro I." #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "B ou B" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "diz ao B para comutar para modo de único utilizador." #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "B ou B" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" "diz ao B para se re-executar a ele próprio (preservando o estado). Não " "acontece o re-examinar do ficheiro I. O runlevel deve ser um " "de B caso contrário o pedido será ignorado em silêncio." #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" "O B pode dizer ao B quanto tempo deve esperar entre enviar " "aos processos os sinais B e B. A predefinição é 3 " "segundos, mas isto pode ser mudado com a opção B<-t>." #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" "O B diz ao B para mudar o ambiente para os processos que " "ele gera. O argumento de B<-e> ou está no formato de I=I o qual " "define a variável I para o valor I, ou no formato I (sem o " "sinal de igual) o qual remove a definição da variável I." #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" "O B só pode ser invocado por utilizadores com privilégios " "apropriados." #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" "O binário B verifica se é o B ou o B ao olhar para o " "seu I; o id do verdadeiro processo do B é sempre B<1>. A " "partir conclui que em vez de se chamar o B pode-se simplesmente " "usar o B como um atalho." #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "AMBIENTE" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "" "O B define as seguintes variáveis de ambiente para todos os seus " "filhos:" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "I" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from B." msgstr "" "Como o nome diz. Útil para determinar se um script corre directamente a " "partir do B." #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "O actual nível de execução do sistema." #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "O runlevel anterior (útil após uma mudança de runlevel)." #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" "A consola do sistema. Isto é realmente herdado do kernel; no entanto se não " "for definido o B irá defini-lo para I por predefinição." #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "BOOTFLAGS" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" "É possível passar um número de bandeiras ao B a partir do monitor de " "arranque (ex. LILO ou GRUB). O B aceita as seguintes bandeiras:" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "B<-s, S, single>" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" "Arranque em modo de único utilizador. Neste modo o I é " "examinado e os scripts rc de arranque são geralmente corridos antes da shell " "de modo de único utilizador ser arrancada." #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "B<1-5>" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "O runlevel para o qual arrancar." #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "B<-b, emergency>" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" "Arranca directamente para shell de único utilizador sem correr quaisquer " "scripts de arranque." #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "B<-a, auto>" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to \"yes\". " "Note that you cannot use this for any security measures - of course the user " "could specify \"auto\" or B<-a> on the command line manually." msgstr "" "O boot loader LILO adiciona a palavra \"auto\" à linha de comandos se " "arrancar o kernel com alinha de comandos predefinida (sem intervenção do " "utilizador). Se isto for encontrado o B define a variável de ambiente " "\"AUTOBOOT\" para \"yes\". Note que você não pode usar isto para nenhuma " "medida de segurança - é claro que o utilizador podia especificar \"auto\" ou " "B<-a> na linha de comandos manualmente." #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "B<-z >I" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" "O argumento para B<-z> é ignorado. Você pode usar isto para expandir um " "pouco a linha de comandos, para que tenha mais algum espaço na pilha. O " "B pode então manipular a linha de comandos para que B(1) mostre o " "runlevel actual." #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "B<--version>" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" "Este argumento, quando usado por si só, mostra a versão actual do B na " "consola/stdout. É uma maneira rápida de determinar qual software e versão do " "B está a ser usado. Após a informação de versão ser mostrada, o " "B termina imediatamente com um código de retorno de zero." #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "INTERFACE" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" "O B escuta num I em /dev, I, por mensagens. O " "B usa isto para comunicar com B. A interface não está bem " "documentada nem acabada. Aqueles interessados devem estudar o ficheiro " "I no sub-directório I do arquivo tar do código fonte do " "B." #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "SINAIS" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "O Init reage a vários sinais:" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "Tem o mesmo efeito que B." #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, B. Useful for bootscripts when I is remounted." msgstr "" "Na receção destes sinais, o B fecha e re-abre o seu fifo de controle, " "B. Útil para scripts de arranque quando I é remontado." #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" "Quando o B recebe B, o B fecha e deixa o fifo de " "controle, B, fechado. Isto pode ser usado para certificar que " "o B não está a segurar nenhuns ficheiros abertos. No entanto, também " "previne o B de mudar os runlevels. O que significa que comandos como o " "shutdown não funcionam mais. O fifo pode ser re-aberto ao enviar ao B " "o sinal B." #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" "Normalmente o kernel envia este sinal ao B quando CTRL-ALT-DEL é " "pressionado. Activa a acção I." #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" "O kernel envia este sinal quando a tecla I é pressionada. " "Activa a acção I." #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "CONFORMIDADE COM" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" "O B é compatível com o init do System V. Funcionam muito próximos com " "os scripts nos directórios I e I. Se o seu " "sistema usa esta convenção, deverá existir um ficheiro I no " "directório I a explicar como estes scripts trabalham." #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "FICHEIROS" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "AVISOS" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" "O B assume que os processos e os descendentes dos processos permanecem " "no mesmo grupo de processos que foi originalmente criado para eles. Se os " "processos mudarem o seu grupo, o B não consegue mata-los e você pode " "acabar com dois processos a ler a partir de uma linha de terminal." #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" "Num sistema Debian, entrar no runlevel 1 faz com que todos os processos " "sejam mortos excepto para tópicos de kernel e o script que faz a matança e " "outros processos na sua sessão. Como consequência disto, não é seguro " "retornar de runlevel 1 para um runlevel de multi-utilizador: os daemons que " "foram arrancados no runlevel S e são precisos para o funcionamento normal " "não estão mais a correr. O sistema deve ser reiniciado." #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" "Se o B descobrir que está continuamente a renascer uma entrada mais de " "10 vezes em 2 minutos,irá assumir que existe um erro na string de comando, " "gerar uma mensagem de erro na consola do sistema, e recusar o renascer desta " "entrada até que ou tenham passado 5 minutos ou tenha recebido um sinal. Isto " "previne de comer os recursos do sistema quando alguém comete um erro " "tipográfico no ficheiro I ou o programa para a entrada foi " "removido." #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "INITCTL" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "13 Abril, 2018" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "Formatos de Ficheiro" #. type: Plain text #: ../initctl.5:20 msgid "" "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" "initctl - /run/initctl é um pipe nomeado que passa comandos ao init do SysV" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "/run/initctl" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" "Este documento descreve o canal de comunicação definido pelo SysV B em " "I. Este pipe nomeado permite a programas com as permissões " "apropriadas (tipicamente os programas corridos pelo root têm acesso de " "leitura-escrita ao pipe) enviarem sinais ao programa B (PID 1)." #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" "O manual do B tem, até recentemente, simplesmente dito que as pessoas " "que desejam perceber como enviar mensagens ao B devem ler o código " "fonte do programa init, mas isso não é geralmente prático." #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" "As mensagens enviadas para o pipe para falar com o B têm de ter um " "formato especial. Este formato está definido como uma estrutura C e a parte " "técnica é apresentada aqui:" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" "Vamos avançar pela estrutura de init_request uma linha de cada vez. A " "primeira variável, o número \"mágico\" tem de ser do valor 0x03091969. O " "program B então sabe que apenas programas com acesso de root que " "enviam este número mágico estão autorizados a comunicar com o init." #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" "A variável I é um valor na gama de 0-8 (actualmente). Esta variável " "I diz ao init o que queremos fazer. Aqui estão as opções possíveis:" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "1 - Define o runlevel actual, especificado pela variável runlevel." #. type: Plain text #: ../initctl.5:68 msgid "" "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" "2 - A energia vai falhar em breve (provavelmente bateria fraca), prepara " "para desligar." #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "3 - A energia está a falhar, desligar imediatamente." #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "4 - A energia está OK, cancelar o desligar." #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" "6 - Define uma variável de ambiente a um valor a ser especificado na\n" " variável I com esta estrutura.\n" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" "Podem ser adicionadas outras opções I ao B mais tarde. Por " "exemplo, os valores de comando 0, 5 e 7 estão definidos mas actualmente não " "implementados." #. type: Plain text #: ../initctl.5:80 msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "" "A variável I irá especificar o runlevel para se mudar para (0-6)." #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" "A variável I é usada quando queremos dizer ao B para mudar " "o tempo de espera entre enviar B e B durante o processo de " "encerramento. Ainda não está implementado alterar isto durante a execução." #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" "A variável I (na união) pode ser usada para passar dados diversos que " "o init pode precisar para processar o nosso pedido. Por exemplo, quando se " "definem variáveis de ambiente." #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" "Quando se define uma variável de ambiente através do pipe I do " "B, a variável data deve ter o formato I=I. A string " "deve ser terminada com um caractere NULL." #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" "O seguinte exemplo de código C mostra como enviar um pedido de definição de " "variável de ambiente ao processo B usando o pipe I. Este " "exemplo está simplificado e salta a verificação de erros. Um exemplo mais " "complexo pode ser encontrado na função B() do programa shutdown." "c." #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" msgstr "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init */\n" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write */\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe */\n" " close(fd); /* close the pipe when done */\n" "}\n" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" "Normalmente o pipe I seria apenas usado por programas de baixo-" "nível para pedir um encerramento relacionado com energia ou para mudar o " "runlevel, como o B faria. Na maioria do tempo não há necessidade de " "falar com o B diretamente, mas isto dá-nos uma aproximação extensiva " "de que o B pode ser ensinado a aprender mais comandos." #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" "Os comandos passados pelo canal I têm de ser enviados num " "formato binário específico e ter um tamanho específico. Estruturas de dados " "maiores ou que não usem o formato apropriado serão ignoradas. Tipicamente, " "apenas o root tem a habilidade de escrever no pipe initctl por razões de " "segurança." #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" "O canal I pode ser fechado ao se enviar ao init (PID 1) o " "sinal B. Isto fecha o pipe e deixa-o fechado. Isto pode ser útil " "para certificar que o B não deixa ficheiros abertos. No entanto, " "quando o pipe está fechado, o B não recebe mais sinais, tais como " "aqueles enviados pelo B(8) ou B(8). Por outras palavras, " "se fecharmos o canal, o B não pode o seu runlevel diretamente. O canal " "pode ser reaberto ao enviar ao B (PID 1) o sinal B." #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" "Se o canal I estiver fechado então ainda deve ser possível " "desligar o sistema usando a bandeira B<-n> do comando B(8), mas " "isto nem sempre é limpo e não é recomendado." #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "/run/initctl /sbin/init" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "INITSCRIPT" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "10 Julho, 2003" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "initscript - script que executa comandos do inittab." #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "/bin/sh /etc/initscript id runlevels action process" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" "Quando o script de shell I está presente, o B irá usa-" "lo para executar os comandos de I. Este script pode ser usado para " "definir coisas como os valores predefinidos de I e I para " "qualquer processo." #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as I." msgstr "" "Este é um initscript exemplo, que pode estar instalado no seu sistema em I." #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" msgstr "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE EactionE EprocessE\n" "#\n" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" " # Define umask para nível seguro, e activa despejos do núcleo.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" " # Aumenta o limite rijo de descritor de ficheiro para todos os processos\n" " # para 8192. O limite suave é ainda 1024, mas qualquer processo não\n" " # privilegiado pode aumentar o seu limite suave até ao limite rijo\n" " # com \"ulimit -Sn xxx\" (precisa dum kernel Linux 2.2.13 ou posterior).\n" " ulimit -Hn 8192\n" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" " # Executa o programa.\n" " eval exec \"$4\"\n" #. type: Plain text #: ../initscript.5:65 msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" "Este script não se destina a ser script de arranque para daemons ou " "serviços. Não tem nada a ver com um script de estilo I. É apenas " "para manusear coisas executadas a partir de B. Fazer " "experiências com isto pode tornar o seu sistema não (re)inicializável." #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "/etc/inittab, /etc/initscript." #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "B(5), B(8)" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "INITTAB" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "4 Dezembro, 2001" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init process" msgstr "" "inittab - formato do ficheiro inittab usando pelo processo init compatível " "com sysv" #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" "O ficheiro B descreve quais processos são iniciados no arranque e " "durante a operação normal (ex. \\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). O B(8) distingue múltiplos I, cada um dos " "quais pode ter o seu próprio conjunto de processos que é arrancado. Os " "runlevels válidos são B<0>-B<6> mais B, B, e B para entradas " "B. Uma entrada no ficheiro B tem o seguinte formato:" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "I:I:I:I" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "As linhas que começam com `#' são ignoradas." #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:48 msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" "é uma sequência única de 1-4 caracteres que identifica uma entrada em " "B (para versões do sysvinit compiladas com a I libc5 (E " "5.2.18) ou bibliotecas a.out o limite é de 2 caracteres)." #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" "Nota: tradicionalmente, para o getty e outros processos de login, este valor " "do campo I é mantido no mesmo que o sufixo do tty correspondente, ex. " "\\& B<1> para B. Alguns programas antigos de contabilidade de login " "podem esperar isto, apesar de não me lembrar de nenhum." #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "lista os runlevels para os quais a acção especificada deve ser tomada." #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "I" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "descreve qual a acção que deve ser tomada." #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "I" #. type: Plain text #: ../inittab.5:70 msgid "" "specifies the process to be executed. If the process field starts with a `" "+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" "especifica o processo a ser executado. Se o campo de processo começar com um " "caractere `+', o B não irá contabilizar tmp e wtmp para esse processo. " "Isto é preciso para gettys que insistem em fazer a sua própria limpeza utmp/" "wtmp. Isto é também um bug histórico. O comprimento deste campo está " "limitado a 127 caracteres." #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" "Por favor note que incluir certos caracteres no campo de processo irá " "resultar no B a tentar lançar uma shell para interpretar o comando " "contido no campo de processo. Os caracteres que pode despoletar uma shell " "são: B<~`!$^&*()=|\\{}[];>" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" "Em sistemas que não tenham uma shell para ser lançada ou quais não se deseja " "usar uma shell para interpretar o campo do processo, o campo de processo " "pode ser prefixado com o símbolo @. O @ irá ser ignorado e tudo o que se " "segue será tratado como o comando a ser lançado, literalmente, pelo " "serviço B." #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" "Em casos que ambos sinais + e @ vão ser usados (para desligar os relatórios " "e interpretação da shell) coloque o sinal + antes do símbolo @. Ambas " "bandeiras irão ser lidadas e depois tudo o que se segue ao @ irá ser lidado " "pelo B" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" "O campo I pode conter vários caracteres para diferentes " "runlevels. Por exemplo, B<123> especifica que o processo deve ser iniciado " "nos runlevels 1, 2, e 3. Os I para entradas B podem " "conter um B, B, ou B. O campo I das entradas B, " "B, e B é ignorado." #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" "Quando o runlevel do sistema é mudado, quaisquer processos a correr que não " "estão especificados para o novo runlevel são mortos, primeiro com " "\\s-2SIGTERM\\s0, e depois com \\s-2SIGKILL\\s0." #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "As acções válidas para o campo I são:" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "O processo será reiniciado sempre que termine (ex. \\& getty)." #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" "O processo irá ser iniciado assim que se entra no runlevel especificado e o " "B irá esperar pelo seu término." #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "" "The process will be executed once when the specified runlevel is entered." msgstr "" "O processo irá ser executado uma vez quando se entra no runlevel " "especificado." #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" "O processo será executado durante o arranque do sistema. O campo " "I é ignorado." #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" "O processo será executado durante o arranque do sistema, enquanto B " "espera pelo seu término (ex. \\& /etc/rc). O campo I é ignorado." #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "Isto não faz nada." #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" "Um processo marcado com um runlevel B será executado sempre que o " "runlevel B especificado é chamado. No entanto, nenhuma mudança de " "runlevel irá ocorrer (os runlevels B são `a', `b', e `c')." #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" "Uma entrada B especifica o runlevel em que se deve entrar após " "o arranque do sistema. Se não existir nenhum, o B irá pedir um " "runlevel na consola. O campo I é ignorado." #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" "O processo será executado durante o arranque do sistema. Será executado " "antes de qualquer entrada B ou B< bootwait>. O campo I é " "ignorado." #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" "O processo será executado quando a energia vai abaixo. O B é " "geralmente informado disto por um processo que fala com uma UPS ligada ao " "computador. O B irá esperar que o processo termine antes de continuar." #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" "Como para B, excepto que o B não espera pelo final do " "processo." #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" "Este processo será executado assim que o B é informado que a energia " "foi restaurada." #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" "Este processo será executado quando é dito ao B que a bateria da UPS " "externa está quase vazia e a energia está a falhar (desde que a UPS externa " "e o processo de monitorização sejam capazes de detectar esta condição)." #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "B" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" "O processo será executado quando o B receber o sinal B. Isto " "significa que alguém na consola do sistema pressionou a combinação de teclas " "B. Tipicamente alguém quer executar alguma espécie de " "B seja para ir para nível de único-utilizador ou para reiniciar a " "máquina." #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" "O processo será executado quando o B receber um sinal a partir do " "manipulador do teclado que uma combinação especial de teclas foi pressionada " "no teclado da consola." #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" "A documentação para esta função ainda não está completa; pode ser encontrada " "mais informação nos pacotes kbd-x.xx (o mais recente foi kbd-0.94 na altura " "que isto foi escrito). Basicamente você deseja mapear alguma combinação do " "teclado para a acção \"KeyboardSignal\". Por exemplo, para mapear Alt-" "SetaCima para este objectivo use o seguinte no seu ficheiro keymaps:" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "alt keycode 103 = KeyboardSignal" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "" "Isto é um exemplo de uma inittab que é semelhante à inittab antiga do Linux:" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" #. type: Plain text #: ../inittab.5:222 msgid "" "This inittab file executes I during boot and starts gettys on tty1-" "tty4." msgstr "" "Este ficheiro inittab executa I durante o arranque e inicia gettys " "em tty1-tty4." #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" "Uma B mais elaborada com diferentes runlevels (veja os comentários " "no interior):" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" "# Nível para onde correr\n" "id:2:initdefault:\n" #. type: Plain text #: ../inittab.5:234 #, no-wrap msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" "# Script de configuração/inicialização do sistema durante o arranque.\n" "si::sysinit:/etc/init.d/rcS\n" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" "# O que fazer em modo de único-utilizador.\n" "~:S:wait:/sbin/sulogin\n" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" "# /etc/init.d executa os scripts S e K na comutação\n" "# do runlevel.\n" "#\n" "# Runlevel 0 é parar.\n" "# Runlevel 1 é único-utilizador.\n" "# Runlevels 2-5 são multi-utilizador.\n" "# Runlevel 6 é reiniciar.\n" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" "# O que fazer na \"saudação dos 3 dedos\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" #. type: Plain text #: ../inittab.5:265 #, no-wrap msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "/etc/inittab" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT lederer@\\:" "francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> and " "modified by E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" "B foi escrito por E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> Este manual foi escrito por E<.MT lederer@\\:francium" "\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer E<.ME> e modificado por " "E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> Michael Haardt E<." "ME .>" #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "B(8), B(8)" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "KILLALL5" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "4 Novembro 2003" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "killall5 - envia um sinal a todos os processos" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" "B é o comando B do SystemV. Envia um sinal a todos os " "processos excepto tópicos do kernel e aos processos da sua própria sessão, " "assim não mata a shell que está a correr o script de onde foi chamado. O seu " "uso principal (e único) está nos scripts B encontrados no directório I." #. type: IP #: ../killall5.8:35 #, no-wrap msgid "B<-o> I" msgstr "B<-o> I" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "Diz ao B para omitir processos com esse id de processo." #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" "O B também pode ser invocado como B(8), o que é " "simplesmente um link (simbólico) para o programa B." #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" "O programa retorna zero se matou processos. Retorna 2 se nenhum processo foi " "morto, e 1 se foi incapaz de encontrar quaisquer processos (I em " "falta)." #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "B(8), B(8), B(8)" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "LAST," #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "1" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "31 Julho, 2004" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "" "last, lastb - mostra listagem dos últimos utilizadores que fizeram login" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B I] [-B I] [I] [I]" msgstr "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B " "I] [-B I] [I] [I]" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" msgstr "" "B [B<-R>] [B<->I] [-B I] [-B I] [B<-" "adFiowx>] [I] [I]" #. type: Plain text #: ../last.1:56 msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" "B procura para trás no ficheiro B (ou no ficheiro " "designado pela bandeira B<-f>) e mostra uma lista de todos os utilizadores " "que fizeram login (e logout) desde que esse ficheiro foi criado. Podem ser " "dados nomes de utilizadores e tty's, que neste caso o B irá apenas " "mostrar aquelas entradas que correspondem aos argumentos. Os nomes dos ttys " "podem ser abreviados, assim B é o mesmo que B." #. type: Plain text #: ../last.1:61 msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" "Quando o B apanha um sinal B (gerado pela tecla de " "interrupção, normalmente control-C) ou um sinal B (gerado pela " "tecla de desistir, geralmente control-\\e), o B irá mostrar até onde " "pesquisou no ficheiro; no caso do sinal B o B irá depois " "terminar." #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was created." msgstr "" "O pseudo utilizador B faz login cada vez que o sistema é reiniciado. " "Assim B irá mostrar um registo de todas as vezes que o sistema " "reiniciou desde que o ficheiro de registo foi criado." #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" "B é o mesmo que B, excepto que por predefinição mostra um " "registo do ficheiro B, que contém todas as tentativas " "falhadas de login." #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "B<-f> I" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" "Diz ao B para usar um ficheiro especifico em vez de I." #. type: IP #: ../last.1:73 #, no-wrap msgid "B<->I" msgstr "B<->I" #. type: Plain text #: ../last.1:75 msgid "This is a count telling B how many lines to show." msgstr "Isto é uma contagem que diz ao B quantas linhas deve mostrar." #. type: IP #: ../last.1:75 #, no-wrap msgid "B<-n> I" msgstr "B<-n> I" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "O mesmo." #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "B<-t> I" #. type: Plain text #: ../last.1:82 msgid "" "Display the state of logins as of the specified time. This is useful, e.g., " "to determine easily who was logged in at a particular time -- specify that " "time with B<-t> and look for \"still logged in\"." msgstr "" "Mostra o estados dos logins da hora especificada. Isto é útil, ex. para " "determinar facilmente quem tinha login aberto numa hora particular -- " "especifique essa hora com B<-t> e procura por \"ainda com login aberto\"." #. type: IP #: ../last.1:82 #, no-wrap msgid "B<-R>" msgstr "B<-R>" #. type: Plain text #: ../last.1:84 msgid "Suppresses the display of the hostname field." msgstr "Suprime o amostrar do campo hostname." #. {{{ -a #. type: IP #: ../last.1:84 ../logsave.8:40 ../shutdown.8:56 #, no-wrap msgid "B<-a>" msgstr "B<-a>" #. type: Plain text #: ../last.1:87 msgid "" "Display the hostname in the last column. Useful in combination with the next " "flag." msgstr "" "Mostra o hostname na última coluna. Útil em combinação com a próxima " "bandeira." #. type: Plain text #: ../last.1:91 msgid "" "For non-local logins, Linux stores not only the host name of the remote host " "but its IP number as well. This option translates the IP number back into a " "hostname." msgstr "" "Para os logins não locais, o Linux guarda não apenas o nome da máquina da " "máquina remota mas também o seu número IP. Esta opção traduz o número IP de " "volta para um hostname." #. type: IP #: ../last.1:91 ../shutdown.8:91 #, no-wrap msgid "B<-F>" msgstr "B<-F>" #. type: Plain text #: ../last.1:93 msgid "Print full login and logout times and dates." msgstr "Escreve as horas e datas de todos os login e logout." #. type: Plain text #: ../last.1:96 msgid "" "This option is like B<-d> in that it displays the IP number of the remote " "host, but it displays the IP number in numbers-and-dots notation." msgstr "" "Esta opção é como B<-d> em que mostra o número IP da máquina remota, mas " "mostra o número IP em notação de números e pontos." #. type: IP #: ../last.1:96 #, no-wrap msgid "B<-l>" msgstr "B<-l>" #. type: Plain text #: ../last.1:100 msgid "" "This option allows the display of usernames longer than 8 characters. This " "may mess up formatting in some programs and make the output wider than the " "standard 80 characters." msgstr "" "Esta opção permite a mostragem de nomes de utilizadores maiores que 8 " "caracteres. Isto pode estragar a formatação em alguns programas e tornar os " "resultados mais largos que o standard de 80 caracteres." #. type: IP #: ../last.1:100 ../utmpdump.1:33 #, no-wrap msgid "B<-o>" msgstr "B<-o>" #. type: Plain text #: ../last.1:102 msgid "Read an old-type wtmp file (written by linux-libc5 applications)." msgstr "" "Lê um ficheiro wtmp de tipo antigo (escrito por aplicações de linux-libc5)." #. type: Plain text #: ../last.1:104 msgid "Display full user and domain names in the output." msgstr "Mostra nomes completos de utilizador e domínio no resultado." #. type: IP #: ../last.1:104 ../mountpoint.1:40 ../pidof.8:63 #, no-wrap msgid "B<-x>" msgstr "B<-x>" #. }}} #. type: Plain text #: ../last.1:107 msgid "Display the system shutdown entries and run level changes." msgstr "" "Mostra entradas de encerramento do sistema e mudanças de nível de execução." #. {{{ Files #. type: Plain text #: ../last.1:114 msgid "" "The files I and I might not be found. The system only logs " "information in these files if they are present. This is a local " "configuration issue. If you want the files to be used, they can be created " "with a simple B(1) command (for example, B)." msgstr "" "Os ficheiros I e I podem não existir. O sistema apenas regista " "informação nestes ficheiros se eles estiverem presentes. Isto é um problema " "de configuração local. Se você deseja que estes ficheiros sejam usados, eles " "podem ser criados com um simples comando B(1) (por exemplo, B)." #. type: Plain text #: ../last.1:116 msgid "/var/log/wtmp" msgstr "/var/log/wtmp" #. }}} #. {{{ Author #. type: Plain text #: ../last.1:120 msgid "/var/log/btmp" msgstr "/var/log/btmp" #. type: Plain text #: ../last.1:129 msgid "B(8), B(1), B(8)" msgstr "B(8), B(1), B(8)" #. type: TH #: ../logsave.8:5 #, no-wrap msgid "LOGSAVE" msgstr "LOGSAVE" #. type: Plain text #: ../logsave.8:8 msgid "logsave - save the output of a command in a logfile" msgstr "logsave - salva o resultado de um comando num ficheiro de registo" #. type: Plain text #: ../logsave.8:14 msgid "B [ B<-asv> ] I" msgstr "B [ B<-asv> ] I" #. type: Plain text #: ../logsave.8:27 msgid "" "The B program will execute I with the specified " "argument(s), and save a copy of its output to I. If the containing " "directory for I does not exist, B will accumulate the " "output in memory until it can be written out. A copy of the output will " "also be written to standard output." msgstr "" "O programa B irá executar I com os argumentos " "especificados, e guardar uma cópia do seu resultado no I. Se o " "directório para conter o I não existir, o B irá acumular o " "resultado em memória até que possa ser escrito. Uma cópia do resultado " "também será escrita na saída standard." #. type: Plain text #: ../logsave.8:34 msgid "" "If I is a single hyphen ('-'), then instead of executing a " "program, B will take its input from standard input and save it in " "I." msgstr "" "Se I for um único hífen ('-'), então em vez de executar um " "programa, o B irá tomar a sua entrada a partir da entrada standard " "e guarda-la no I." #. type: Plain text #: ../logsave.8:39 msgid "" "B is useful for saving the output of initial boot scripts until the " "I partition is mounted, so the output can be written to I." msgstr "" "O B é útil para salvar o resultado dos scripts de arranque inicial " "até que a partição I seja montada, para que o resultado seja gravado " "em I." #. type: Plain text #: ../logsave.8:45 msgid "" "This option will cause the output to be appended to I, instead of " "replacing its current contents." msgstr "" "Esta opção irá fazer com que o resultado seja acrescentado ao I, em " "vez de substituir o seu conteúdo actual." #. type: Plain text #: ../logsave.8:53 msgid "" "This option will cause B to skip writing to the log file text which " "is bracketed with a control-A (ASCII 001 or Start of Header) and control-B " "(ASCII 002 or Start of Text). This allows progress bar information to be " "visible to the user on the console, while not being written to the log file." msgstr "" "Esta opção fará com que o B salte escrever no ficheiro de registo o " "texto que está envolto com um control-A (ASCII 001 ou Inicio de Cabeçalho) e " "control-B (ASCII 002 ou Inicio de Texto). Isto permite que a informação da " "barra de progresso esteja visível par ao utilizador, e não ser escrita no " "ficheiro de registo." #. type: Plain text #: ../logsave.8:58 msgid "" "This option will make B to be more verbose in its output to the " "user." msgstr "" "Esta opção fará com que o B seja mais detalhado no seu resultado " "para o utilizador." #. type: Plain text #: ../logsave.8:62 msgid "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" msgstr "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" #. type: Plain text #: ../logsave.8:63 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "MESG" msgstr "MESG" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "Feb 26, 2001" msgstr "26 Fevereiro, 2001" #. type: TH #: ../mesg.1:20 ../mountpoint.1:18 ../readbootlog.1:20 ../utmpdump.1:18 #: ../wall.1:18 #, no-wrap msgid "User Commands" msgstr "Comandos de Utilizador" #. }}} #. {{{ Synopsis #. type: Plain text #: ../mesg.1:27 msgid "mesg - control write access to your terminal" msgstr "mesg - controla o acesso de escrita ao seu terminal" #. }}} #. {{{ Description #. type: Plain text #: ../mesg.1:32 msgid "B [B|B]" msgstr "B [B|B]" #. }}} #. {{{ Options #. type: Plain text #: ../mesg.1:38 msgid "" "B controls the access to your terminal by others. It's typically used " "to allow or disallow other users to write to your terminal (see B(1))." msgstr "" "B controla o acesso ao seu terminal por outros. É tipicamente usado " "para permitir ou proibir que outros utilizadores escrevam no seu terminal " "(veja B(1))." #. type: IP #: ../mesg.1:39 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:41 msgid "Allow write access to your terminal." msgstr "Permite acesso de escrita ao seu terminal." #. type: IP #: ../mesg.1:41 #, no-wrap msgid "B" msgstr "B" #. type: Plain text #: ../mesg.1:43 msgid "Disallow write access to your terminal." msgstr "Retira permissão de acesso de escrita ao seu terminal." #. }}} #. {{{ Notes #. type: Plain text #: ../mesg.1:48 msgid "" "If no option is given, B prints out the current access state of your " "terminal." msgstr "" "Se não for dada nenhuma opção, o B escreve o estado de acesso actual " "do seu terminal." #. type: Plain text #: ../mesg.1:53 msgid "" "B assumes that its standard input is connected to your terminal. That " "also means that if you are logged in multiple times, you can get/set the " "mesg status of other sessions by using redirection. For example \"mesg n " "E /dev/pts/46\"." msgstr "" "O B assume que a sua entrada standard está ligada ao seu terminal. " "Isso também significa que se você tiver vários logins abertos, você pode " "obter/definir o estado do mesg de outras sessões ao usar redirecionamento. " "Por exemplo, \"mesg n E /dev/pts/46\"." #. type: Plain text #: ../mesg.1:62 msgid "B(1), B(1), B(1)" msgstr "B(1), B(1), B(1)" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "MOUNTPOINT" msgstr "PONTO DE MONTA" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "Mar 15, 2004" msgstr "15 Março, 2004" #. type: Plain text #: ../mountpoint.1:21 msgid "mountpoint - see if a directory is a mountpoint" msgstr "mountpoint - vê se um directório é um ponto de montagem" #. type: Plain text #: ../mountpoint.1:26 msgid "B [B<-q>] [B<-d>] I" msgstr "B [B<-q>] [B<-d>] I" #. type: Plain text #: ../mountpoint.1:30 msgid "B B<-x> I" msgstr "B B<-x> I" #. type: Plain text #: ../mountpoint.1:32 msgid "B checks if the directory is a mountpoint." msgstr "B verifica se um directório é um ponto de montagem." #. type: IP #: ../mountpoint.1:34 ../pidof.8:60 ../shutdown.8:107 #, no-wrap msgid "B<-q>" msgstr "B<-q>" #. type: Plain text #: ../mountpoint.1:36 msgid "Be quiet - don't print anything." msgstr "Fica calado - não escreve nada." #. type: Plain text #: ../mountpoint.1:38 msgid "Print major/minor device number of the filesystem on stdout." msgstr "" "Escreve o número de dispositivo maior/menor do sistema de ficheiros no " "stdout." #. type: Plain text #: ../mountpoint.1:40 msgid "" "Check Linux's I file to try to detect circular mount points." msgstr "" "Verifica o ficheiro I do Linux para tentar detectar pontos de " "montagem circulares." #. type: Plain text #: ../mountpoint.1:42 msgid "Print major/minor device number of the blockdevice on stdout." msgstr "" "Escreve o número de dispositivo maior/menor do dispositivo de bloco no " "stdout." #. type: Plain text #: ../mountpoint.1:44 msgid "Zero if the directory is a mountpoint, non-zero if not." msgstr "Zero se o directório for um ponto de montagem, não-zero se não for." #. type: Plain text #: ../mountpoint.1:48 msgid "" "Symbolic links are not followed, except when the B<-x> option is used. To " "force following symlinks, add a trailing slash to the path of the directory." msgstr "" "Os links simbólicos não são seguidos, excepto quando a opção B<-x> é usada. " "Para forçar o seguimento dos links simbólicos, adicione uma barra \"/\" no " "final do caminho do directório." #. type: Plain text #: ../mountpoint.1:52 msgid "" "The name of the command is misleading when the B<-x> option is used, but the " "option is useful for comparing if a directory and a device match up, and " "there is no other command that can print the info easily." msgstr "" "O nome do comando é enganoso quando a opção B<-x> é usada, mas a opção é " "útil para comparar se um directório e um dispositivo correspondem, e não há " "mais nenhum outro comando que consiga escrever a informação com facilidade." #. type: Plain text #: ../mountpoint.1:57 msgid "" "The mountpoint command fails when a directory is binded to one of its " "grandparents. For example, if /a/b/c/d is a mount point for /a/b then " "mountpoint will report /a/b/c/d is not a valid mount point. This is because " "both the original directory and its new mount point share the same inode and " "device number." msgstr "" "O comando mountpoint falha quando um directório é cego por um dos seus avôs. " "Por exemplo, se /a/b/c/d for um ponto de montagem para /a/b então o " "mountpoint irá reportar que /a/b/c/d não é um ponto de montagem válido. Isto " "deve-se a que ambos o directório original e o seu novo ponto de montagem " "partilham o mesmo inode e número de dispositivo." #. type: Plain text #: ../mountpoint.1:66 msgid "" "The circular mount problem can be worked around on Linux systems by using " "theB<-p> flag to check the I file for references to the " "circular mount bind. When using the B<-p> flag, make sure to specify the " "full path (ie I and not just I). Also, B may " "still fail if there are spaces in the mount point's path, even when using " "the B<-p> flag because of the way B mangles the spaces in the " "path name. Of course, if the admin is using circular mount points with " "spaces in the name, there are bigger concerns." msgstr "" "O problema de montagem circular pode ser contornado em sistemas Linux ao " "usar a bandeira B<-p> para verificar no ficheiro I por " "referências a vínculo de montagem circular. Quando se usar a bandeira B<-p>, " "certifique de especificar o caminho completo (isto é, I e não " "apenas I). Também, o B pode ainda falhar se existirem " "espaços no caminho dos pontos de montagem, mesmo usando a bandeira B<-p> " "devido ao modo que o B lida com os espaços no nome do caminho. " "Claro que, se o administrador está a usar pontos de montagem circulares com " "espaços no nome, existem grandes preocupações." #. type: Plain text #: ../mountpoint.1:71 msgid "B(1)" msgstr "B(1)" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "PIDOF" msgstr "PIDOF" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "01 Sep 1998" msgstr "1 Setembro 1998" #. type: Plain text #: ../pidof.8:21 msgid "pidof - find the process ID of a running program" msgstr "pidof - encontra o ID de processo de um programa a correr" #. type: Plain text #: ../pidof.8:36 msgid "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> I] [B<-o> I] [B<-d> I] I " "[I]" msgstr "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> I] [B<-o> I] [B<-d> I] I " "[I]" #. type: Plain text #: ../pidof.8:44 msgid "" "B finds the process id's (PIDs) of the named programs. It prints " "those id's on the standard output. This program is on some systems used in " "run-level change scripts, especially when the system has a I like " "I structure. In that case these scripts are located in I, " "where ? is the runlevel. If the system has a B(8) program " "that should be used instead." msgstr "" "O B encontra os id's de processos (PIDs) dos programas nomeados. " "Escreve esses id's na saída standard. Este programa é usado em alguns " "sistemas em scripts de mudança de nível de execução, especialmente quando o " "sistema tem uma estrutura I tipo I. Nesse caso estes scripts " "estão localizados em I, onde ? é o runlevel. Se o sistema tem um " "programa B(8) deve ser esse o usado em vez disto." #. type: Plain text #: ../pidof.8:47 msgid "Single shot - this instructs the program to only return one I." msgstr "Single shot - isto instruí o programa a apenas retornar um I." #. type: Plain text #: ../pidof.8:51 msgid "" "Only return process PIDs that are running with the same root directory. " "This option is ignored for non-root users, as they will be unable to check " "the current root directory of processes they do not own." msgstr "" "Apenas retorna PIDs de processos que estão a correr no mesmo directório " "raiz. Esta opção é ignorada para utilizadores não-root, pois seria incapaz " "de verificar o directório raiz actual dos processos que não possui." #. type: Plain text #: ../pidof.8:60 msgid "" "Avoid B(2) system function call on all binaries which are located on " "network based file systems like B. Instead of using this option the " "variable B may be set and exported." msgstr "" "Evita chamar a função de sistema B(2) em todos os binários que estão " "localizados em sistemas de ficheiros baseados em rede como B. Em vez de " "usar esta opção a variável B pode ser definida e exportada." #. type: Plain text #: ../pidof.8:63 msgid "" "Do not display matched PIDs to standard out. Simply exit with a status of " "true or false to indicate whether a matching PID was found." msgstr "" "Não mostra os PIDs correspondentes na saída standard. Simplesmente termina " "com um estado de verdadeiro ou falso para indicar se foi encontrado um PID " "correspondente." #. type: Plain text #: ../pidof.8:66 msgid "" "Scripts too - this causes the program to also return process id's of shells " "running the named scripts." msgstr "" "Scripts too - isto faz o programa também retornar id's de processos de " "shells que correm nos strings nomeados." #. type: IP #: ../pidof.8:66 #, no-wrap msgid "B<-z>" msgstr "B<-z>" #. type: Plain text #: ../pidof.8:73 msgid "" "Try to detect processes which are stuck in zombie (Z) status. Usually these " "processes are skipped as trying to deal with them can cause pidof or related " "tools to hang. Note: In the past pidof would ignore processes in the " "uninterruptable state (D), unless the B<-z> flag was specified. This is no " "longer the case. The B program will find and report processes in the " "D state whether B<-z> is specified or not." msgstr "" "Tenta detectar processos que estão presos em estado zombie (Z). Normalmente " "estes processos são saltados pois tentar lidar com eles causa ao pidof ou a " "ferramentas relacionadas ficarem paradas. Nota: No passado o pidof iria " "ignorar processos no estado ininterrupto (D), a menos que a bandeira B<-z> " "fosse especificada. Este não é mais o caso. O program B irá encontrar " "e reportar processos no estado D quer B<-z> seja especificada ou não." #. type: IP #: ../pidof.8:73 #, no-wrap msgid "-d I" msgstr "-d I" #. type: Plain text #: ../pidof.8:76 msgid "" "Tells I to use I as an output separator if more than one PID is " "shown. The default separator is a space." msgstr "" "Diz ao I para usar I como um separador de resultados se for " "mostrado mais do que um PID. O separador predefinido é um espaço." #. type: IP #: ../pidof.8:76 #, no-wrap msgid "-o I" msgstr "-o I" #. type: Plain text #: ../pidof.8:80 msgid "" "Tells I to omit processes with that process id. The special pid B<" "%PPID> can be used to name the parent process of the B program, in " "other words the calling shell or shell script." msgstr "" "Diz ao I para omitir processos com esse id de processo. O pid " "especial B<%PPID> pode ser usado para nomear o processo pai do programa " "B, por outras palavras, a shell ou script de shell que o chama." #. type: TP #: ../pidof.8:81 #, no-wrap msgid "B<0>" msgstr "B<0>" #. type: Plain text #: ../pidof.8:84 msgid "At least one program was found with the requested name." msgstr "Pelo menos um programa foi encontrado com o nome requisitado." #. type: TP #: ../pidof.8:84 #, no-wrap msgid "B<1>" msgstr "B<1>" #. type: Plain text #: ../pidof.8:87 msgid "No program was found with the requested name." msgstr "Nenhum programa foi encontrado com o nome requisitado." #. type: Plain text #: ../pidof.8:90 msgid "" "I is actually the same program as B(8); the program behaves " "according to the name under which it is called." msgstr "" "I é na realidade o mesmo programa que B(8); o programa " "comporta-se de acordo com o nome pelo qual é chamado." #. type: Plain text #: ../pidof.8:98 msgid "" "When B is invoked with a full pathname to the program it should find " "the pid of, it is reasonably safe. Otherwise it is possible that it returns " "PIDs of running programs that happen to have the same name as the program " "you're after but are actually other programs. Note that the executable name " "of running processes is calculated with B(2), so symbolic links to " "executables will also match." msgstr "" "Quando o B é invocado com um nome de caminho completo para o programa " "que deve encontrar o pid, é razoavelmente seguro. Caso contrário, é " "possível que retorne PIDs de programas a correr que tenham o mesmo nome que " "o programa que procura mas sejam na realidade outros programas. Note que o " "nome executável dos processos que correm é calculado com B(2), " "assim os links simbólicos para executáveis também podem corresponder." #. type: Plain text #: ../pidof.8:103 msgid "" "Zombie processes or processes in disk sleep (states Z and D, respectively) " "are ignored, as attempts to access the stats of these will sometimes fail. " "The B<-z> flag (see above) tells B to try to detect these sleeping " "and zombie processes, at the risk of failing or hanging." msgstr "" "Os processos zombie ou processos em disco adormecido (estados Z e D, " "respetivamente) são ignorados, pois as tentativas de aceder às estatísticas " "destes irá algumas vezes falhar. A bandeira B<-z> (veja em cima) diz ao " "B para tentar detectar estes processos adormecidos e zombie, com o " "risco de falhar ou ficar pendurado." #. type: Plain text #: ../pidof.8:110 msgid "B(8), B(8), B(8), B(8), B(8)" msgstr "B(8), B(8), B(8), B(8), B(8)" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "READBOOTLOG" msgstr "READBOOTLOG" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "NOV 12, 2018" msgstr "12 Novembro, 2018" #. }}} #. {{{ Synopsis #. type: Plain text #: ../readbootlog.1:27 msgid "" "readbootlog - show contents of the boot log, stripping away control " "characters" msgstr "" "readbootlog - mostra o conteúdo do registo de arranque, retirando os " "caracteres de controlo." #. type: Plain text #: ../readbootlog.1:31 msgid "B [B<-h>] [-B I]" msgstr "B [B<-h>] [-B I]" #. }}} #. {{{ Options #. type: Plain text #: ../readbootlog.1:42 msgid "" "B is a tool for reading the boot log (by default I). The program strips away control characters and non-human readable " "contents from the log file. Output is dumped to the terminal where it can be " "piped or redirected to a file." msgstr "" "B é uma ferramenta para ler o registo de arranque (por " "predefinição I). Este programa retira os caracteres de " "controlo e conteúdos não legíveis por humanos do ficheiro de registo. O " "resultado é despejado para o terminal onde pode ser canalizado ou " "redirecionado para um ficheiro." #. type: Plain text #: ../readbootlog.1:45 msgid "" "Tells B to use a specific file instead of I." msgstr "" "Diz ao B para usar um ficheiro especifico em vez de I." #. {{{ Files #. type: Plain text #: ../readbootlog.1:48 msgid "Displays a brief help message." msgstr "Mostra uma mensagem de ajuda breve." #. }}} #. {{{ Author #. type: Plain text #: ../readbootlog.1:52 msgid "/var/log/boot" msgstr "/var/log/boot" #. }}} #. {{{ See also #. type: Plain text #: ../readbootlog.1:58 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" msgstr "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" #. type: Plain text #: ../readbootlog.1:59 msgid "B(8)" msgstr "B(8)" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "RUNLEVEL" msgstr "RUNLEVEL" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "May 27, 1997" msgstr "27 Maio, 1997" #. type: Plain text #: ../runlevel.8:21 msgid "runlevel - find the previous and current system runlevel" msgstr "runlevel - encontra o runlevel anterior e actual do sistema" #. type: Plain text #: ../runlevel.8:24 msgid "B [I]" msgstr "B [I]" #. type: Plain text #: ../runlevel.8:34 msgid "" "B reads the system I file (typically I) to " "locate the runlevel record, and then prints the previous and current system " "runlevel on its standard output, separated by a single space. If there is no " "previous system runlevel, the letter B will be printed instead." msgstr "" "O B lê o ficheiro I do sistema (tipicamente I) para localizar o registo do runlevel, e depois escreve o runlevel " "anterior e actual do sistema na sua saída standard, separados por um espaço " "único. Se não existir um runlevel de sistema anterior, então é escrita a " "letra B." #. type: Plain text #: ../runlevel.8:42 msgid "" "If no I file exists, and if no runlevel record can be found in the I file, B prints the word B and exits " "with an error." msgstr "" "Se nenhum ficheiro I existir, e se nenhum registo de runlevel puder " "ser encontrado no ficheiro I, o B escreve a " "palavra B e termina com erro." #. type: Plain text #: ../runlevel.8:49 msgid "" "B can be used in I scripts as a substitute for the System-V " "B command. However, in newer versions of B(8) this " "information is also available in the environment variables B and " "B." msgstr "" "O B pode ser usado em scripts I como substituto do comando " "B do System-V. No entanto, em versões mais recentes do B(8) " "esta informação está também disponível nas variáveis de ambiente B " "e B." #. {{{ utmp #. type: IP #: ../runlevel.8:51 #, no-wrap msgid "I" msgstr "I" #. }}} #. type: Plain text #: ../runlevel.8:54 msgid "The name of the I file to read." msgstr "O nome do ficheiro I a ler." #. type: Plain text #: ../runlevel.8:57 msgid "B(8), B(5)" msgstr "B(8), B(5)" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "SHUTDOWN" msgstr "SHUTDOWN" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "November 12, 2003" msgstr "12 Novembro, 2003" #. }}} #. {{{ Synopsis #. type: Plain text #: ../shutdown.8:27 msgid "shutdown - bring the system down" msgstr "shutdown - desliga o sistema" #. }}} #. {{{ Description #. type: Plain text #: ../shutdown.8:36 msgid "" "B [B<-akrhPHfFncqQ>] [B<-t> I] I," #~ msgstr "B," sysvinit-3.14/man/po/sysvinit-man.pot000066400000000000000000002705301475234444100177260ustar00rootroot00000000000000# SOME DESCRIPTIVE TITLE # Copyright (C) YEAR Free Software Foundation, Inc. # This file is distributed under the same license as the sysvinit package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: sysvinit 3.05\n" "Report-Msgid-Bugs-To: Your Bugmail \n" "POT-Creation-Date: 2022-05-09 12:43-0300\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "Language: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #. type: TH #: ../bootlogd.8:18 #, no-wrap msgid "BOOTLOGD" msgstr "" #. type: TH #: ../bootlogd.8:18 #, no-wrap msgid "Jul 21, 2003" msgstr "" #. type: TH #: ../bootlogd.8:18 ../fstab-decode.8:20 ../halt.8:20 ../init.8:20 #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 ../killall5.8:18 #: ../last.1:20 ../logsave.8:5 ../mesg.1:20 ../mountpoint.1:18 ../pidof.8:18 #: ../readbootlog.1:20 ../runlevel.8:18 ../shutdown.8:20 ../sulogin.8:18 #: ../utmpdump.1:18 ../wall.1:18 #, no-wrap msgid "sysvinit " msgstr "" #. type: TH #: ../bootlogd.8:18 ../fstab-decode.8:20 ../halt.8:20 ../init.8:20 #: ../killall5.8:18 ../logsave.8:5 ../pidof.8:18 ../runlevel.8:18 #: ../shutdown.8:20 ../sulogin.8:18 #, no-wrap msgid "Linux System Administrator's Manual" msgstr "" #. type: SH #: ../bootlogd.8:19 ../fstab-decode.8:22 ../halt.8:23 ../init.8:23 #: ../initctl.5:18 ../initscript.5:19 ../inittab.5:23 ../killall5.8:19 #: ../last.1:23 ../logsave.8:6 ../mesg.1:23 ../mountpoint.1:19 ../pidof.8:19 #: ../readbootlog.1:23 ../runlevel.8:19 ../shutdown.8:23 ../sulogin.8:19 #: ../utmpdump.1:19 ../wall.1:20 #, no-wrap msgid "NAME" msgstr "" #. type: Plain text #: ../bootlogd.8:21 msgid "bootlogd - record boot messages" msgstr "" #. type: SH #: ../bootlogd.8:21 ../fstab-decode.8:25 ../halt.8:27 ../init.8:27 #: ../initctl.5:20 ../initscript.5:21 ../killall5.8:21 ../last.1:27 #: ../logsave.8:8 ../mesg.1:27 ../mountpoint.1:21 ../pidof.8:21 #: ../readbootlog.1:27 ../runlevel.8:21 ../shutdown.8:27 ../sulogin.8:21 #: ../utmpdump.1:21 ../wall.1:23 #, no-wrap msgid "SYNOPSIS" msgstr "" #. type: Plain text #: ../bootlogd.8:31 msgid "" "B [B<-c>] [B<-d>] [B<-e>] [B<-r>] [B<-s>] [B<-v>] [I< " ">B<-l>I< logfile >] [I< >B<-p>I< pidfile >]" msgstr "" #. type: SH #: ../bootlogd.8:31 ../fstab-decode.8:28 ../halt.8:53 ../init.8:46 #: ../initctl.5:22 ../initscript.5:23 ../inittab.5:28 ../killall5.8:28 #: ../last.1:48 ../logsave.8:14 ../mesg.1:32 ../mountpoint.1:30 ../pidof.8:36 #: ../readbootlog.1:34 ../runlevel.8:24 ../shutdown.8:36 ../sulogin.8:27 #: ../utmpdump.1:25 ../wall.1:28 #, no-wrap msgid "DESCRIPTION" msgstr "" #. type: Plain text #: ../bootlogd.8:35 msgid "" "B runs in the background and copies all strings sent to the " "I device to a logfile. If the I is not accessible, " "the messages will be kept in memory until it is." msgstr "" #. type: SH #: ../bootlogd.8:35 ../halt.8:68 ../killall5.8:34 ../last.1:70 ../logsave.8:39 #: ../mesg.1:38 ../mountpoint.1:33 ../pidof.8:44 ../readbootlog.1:42 #: ../runlevel.8:49 ../shutdown.8:54 ../utmpdump.1:28 ../wall.1:52 #, no-wrap msgid "OPTIONS" msgstr "" #. type: IP #: ../bootlogd.8:36 ../halt.8:75 ../last.1:87 ../mountpoint.1:36 #, no-wrap msgid "B<-d>" msgstr "" #. type: Plain text #: ../bootlogd.8:38 msgid "Do not fork and run in the background." msgstr "" #. type: IP #: ../bootlogd.8:38 #, no-wrap msgid "B<-e>" msgstr "" #. type: Plain text #: ../bootlogd.8:42 msgid "" "Print escape characters to the boot log file. This turns off filtering of " "escape characters and allows tools like GNU B(1) to see and use colour " "control characters (show the log in colour)." msgstr "" #. type: IP #: ../bootlogd.8:42 ../pidof.8:47 ../shutdown.8:101 #, no-wrap msgid "B<-c>" msgstr "" #. type: Plain text #: ../bootlogd.8:47 msgid "" "Attempt to write to the logfile even if it does not yet exist. Without this " "option, B will wait for the logfile to appear before attempting to " "write to it. This behavior prevents B from creating logfiles under " "mount points." msgstr "" #. type: IP #: ../bootlogd.8:47 ../shutdown.8:64 ../utmpdump.1:31 #, no-wrap msgid "B<-r>" msgstr "" #. type: Plain text #: ../bootlogd.8:50 msgid "" "If there is an existing logfile called I rename it to I " "unless I already exists." msgstr "" #. type: IP #: ../bootlogd.8:50 ../logsave.8:45 ../pidof.8:45 #, no-wrap msgid "B<-s>" msgstr "" #. type: Plain text #: ../bootlogd.8:56 msgid "" "Ensure that the data is written to the file after each line by calling " "B(3). This will slow down a B(8) process running in " "parallel." msgstr "" #. type: TP #: ../bootlogd.8:56 ../logsave.8:53 #, no-wrap msgid "B<-v>" msgstr "" #. type: Plain text #: ../bootlogd.8:58 msgid "Show version." msgstr "" #. type: IP #: ../bootlogd.8:58 #, no-wrap msgid "B<-l> I" msgstr "" #. type: Plain text #: ../bootlogd.8:60 msgid "Log to this logfile. The default is I." msgstr "" #. type: IP #: ../bootlogd.8:60 #, no-wrap msgid "B<-p> I" msgstr "" #. type: Plain text #: ../bootlogd.8:62 msgid "Put process-id in this file. The default is no pidfile." msgstr "" #. }}} #. type: SH #: ../bootlogd.8:62 ../halt.8:94 ../initctl.5:119 ../initscript.5:60 #: ../killall5.8:37 ../last.1:107 ../mesg.1:48 ../mountpoint.1:44 ../pidof.8:87 #: ../shutdown.8:216 #, no-wrap msgid "NOTES" msgstr "" #. type: Plain text #: ../bootlogd.8:67 msgid "" "B saves log data which includes control characters. The log is " "technically a text file, but not very easy for humans to read. To address " "this the B(1) command can be used to display the boot log " "without the control characters." msgstr "" #. type: SH #: ../bootlogd.8:67 ../utmpdump.1:52 #, no-wrap msgid "BUGS" msgstr "" #. type: Plain text #: ../bootlogd.8:77 msgid "" "B works by redirecting the console output from the console " "device. (Consequently B requires PTY support in the kernel " "configuration.) It copies that output to the real console device and to a " "log file. There is no standard way of ascertaining the real console device " "if you have a new-style I device (major 5, minor 1) so " "B parses the kernel command line looking for B lines " "and deduces the real console device from that. If that syntax is ever " "changed by the kernel, or a console type is used that B does not " "know about then B will not work." msgstr "" #. type: SH #: ../bootlogd.8:78 ../halt.8:116 ../init.8:337 ../initctl.5:147 #: ../initscript.5:68 ../inittab.5:275 ../killall5.8:48 ../last.1:120 #: ../logsave.8:58 ../mesg.1:53 ../mountpoint.1:66 ../pidof.8:110 #: ../readbootlog.1:52 ../runlevel.8:57 ../shutdown.8:232 ../sulogin.8:84 #: ../utmpdump.1:60 ../wall.1:74 #, no-wrap msgid "AUTHOR" msgstr "" #. type: Plain text #: ../bootlogd.8:82 ../halt.8:122 ../initscript.5:72 ../killall5.8:51 #: ../last.1:126 ../mesg.1:59 ../mountpoint.1:70 ../pidof.8:113 #: ../runlevel.8:60 ../shutdown.8:238 ../sulogin.8:88 ../wall.1:77 msgid "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME>" msgstr "" #. type: SH #: ../bootlogd.8:82 ../fstab-decode.8:67 ../halt.8:122 ../init.8:346 #: ../initctl.5:151 ../initscript.5:72 ../inittab.5:290 ../killall5.8:44 #: ../last.1:126 ../logsave.8:62 ../mesg.1:59 ../mountpoint.1:70 ../pidof.8:104 #: ../readbootlog.1:58 ../runlevel.8:54 ../shutdown.8:238 ../sulogin.8:88 #: ../utmpdump.1:62 ../wall.1:70 #, no-wrap msgid "SEE ALSO" msgstr "" #. type: Plain text #: ../bootlogd.8:85 msgid "B(8), B(3), B(1)" msgstr "" #. type: TH #: ../fstab-decode.8:20 #, no-wrap msgid "FSTAB-DECODE" msgstr "" #. type: TH #: ../fstab-decode.8:20 #, no-wrap msgid "May 2006" msgstr "" #. type: Plain text #: ../fstab-decode.8:24 msgid "fstab-decode - run a command with fstab-encoded arguments" msgstr "" #. type: Plain text #: ../fstab-decode.8:27 msgid "B I [I]..." msgstr "" #. type: Plain text #: ../fstab-decode.8:34 msgid "" "B decodes escapes (such as newline characters and other " "whitespace) in the specified Is and uses them to run I. " "The argument escaping uses the same rules as path escaping in I, " "I and I." msgstr "" #. type: Plain text #: ../fstab-decode.8:38 msgid "" "In essence B can be used anytime we want to pass multiple " "parameters to a command as a list of command line arguments. It turns output " "like this:" msgstr "" #. type: Plain text #: ../fstab-decode.8:43 #, no-wrap msgid "" "/root\n" "/mnt/remote-disk\n" "/home\n" msgstr "" #. type: Plain text #: ../fstab-decode.8:49 #, no-wrap msgid "" "Into one long list of parameters, \"/root /mnt/remote-disk /home\". This\n" "can be useful when trying to work with multiple filesystems at once. For\n" "instance, we can use it to unmount multiple NFS shares. This program also\n" "removes whitespace and other characters which might cause programs such\n" "as B(8) or B(8) to fail.\n" msgstr "" #. type: SH #: ../fstab-decode.8:50 ../killall5.8:40 ../mountpoint.1:42 ../pidof.8:80 #, no-wrap msgid "EXIT STATUS" msgstr "" #. type: Plain text #: ../fstab-decode.8:56 msgid "" "B exits with status 127 if I can't be run. Otherwise " "it exits with the status returned by I." msgstr "" #. }}} #. }}} #. {{{ Examples #. type: SH #: ../fstab-decode.8:57 ../initctl.5:93 ../initscript.5:28 ../inittab.5:204 #, no-wrap msgid "EXAMPLES" msgstr "" #. type: Plain text #: ../fstab-decode.8:62 msgid "" "The following example reads I, finds all instances of VFAT " "filesystems and prints their mount points (argument 2 in the I " "file). B then runs the specified program, B(8), and " "passes it the list of VFAT mountpoints. This unmounts all VFAT partitions." msgstr "" #. type: Plain text #: ../fstab-decode.8:65 #, no-wrap msgid "" "B\n" msgstr "" #. type: Plain text #: ../fstab-decode.8:68 msgid "B(5)" msgstr "" #. type: TH #: ../halt.8:20 #, no-wrap msgid "HALT" msgstr "" #. type: TH #: ../halt.8:20 #, no-wrap msgid "Nov 6, 2001" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../halt.8:27 msgid "halt, reboot, poweroff - stop the system" msgstr "" #. type: Plain text #: ../halt.8:36 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-p>] [B<-h>]" msgstr "" #. type: Plain text #: ../halt.8:43 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../halt.8:53 msgid "B [B<-n>] [B<-w>] [B<-d>] [B<-f>] [B<-i>] [B<-h>]" msgstr "" #. type: Plain text #: ../halt.8:57 msgid "" "B notes that the system is being brought down in the file " "I, and then either tells the kernel to halt, reboot or " "power-off the system." msgstr "" #. type: Plain text #: ../halt.8:63 msgid "" "If B or B is called when the system is I in runlevel B<0> " "or B<6>, in other words when it's running normally, B will be " "invoked instead (with the B<-h> or B<-r> flag). For more info see the " "B(8) manpage." msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../halt.8:68 msgid "" "The rest of this manpage describes the behavior in runlevels 0 and 6, that " "is when the systems shutdown scripts are being run." msgstr "" #. type: IP #: ../halt.8:69 ../pidof.8:51 ../shutdown.8:95 ../wall.1:53 #, no-wrap msgid "B<-n>" msgstr "" #. type: Plain text #: ../halt.8:72 msgid "" "Don't sync before reboot or halt. Note that the kernel and storage drivers " "may still sync. This implies B<-d>." msgstr "" #. type: IP #: ../halt.8:72 ../last.1:102 #, no-wrap msgid "B<-w>" msgstr "" #. type: Plain text #: ../halt.8:75 msgid "" "Don't actually reboot or halt but only write the wtmp record (in the " "I file)." msgstr "" #. type: Plain text #: ../halt.8:77 msgid "Don't write the wtmp record." msgstr "" #. type: IP #: ../halt.8:77 ../shutdown.8:87 ../utmpdump.1:29 #, no-wrap msgid "B<-f>" msgstr "" #. type: Plain text #: ../halt.8:79 msgid "Force halt or reboot, don't call B(8)." msgstr "" #. type: IP #: ../halt.8:79 ../last.1:93 #, no-wrap msgid "B<-i>" msgstr "" #. type: Plain text #: ../halt.8:83 msgid "" "Shut down all network interfaces just before B or B. Warning: " "This may not work on interfaces which do not have an IP address and should " "ideally be handled by a network manager service." msgstr "" #. type: IP #: ../halt.8:83 ../readbootlog.1:45 ../shutdown.8:68 ../utmpdump.1:35 #, no-wrap msgid "B<-h>" msgstr "" #. type: Plain text #: ../halt.8:85 msgid "" "Put all hard drives on the system in stand-by mode just before halt or " "power-off." msgstr "" #. type: IP #: ../halt.8:85 ../mountpoint.1:38 #, no-wrap msgid "B<-p>" msgstr "" #. }}} #. {{{ Diagnostics #. type: Plain text #: ../halt.8:90 msgid "" "When halting the system, switch off the power. This is the default when " "B is called as B." msgstr "" #. type: SH #: ../halt.8:90 ../init.8:327 #, no-wrap msgid "DIAGNOSTICS" msgstr "" #. }}} #. {{{ Notes #. type: Plain text #: ../halt.8:94 msgid "If you're not the superuser, you will get the message `must be superuser'." msgstr "" #. type: Plain text #: ../halt.8:103 msgid "" "Under older B releases, B and B should never be " "called directly. From release 2.74 on B and B invoke " "B(8) if the system is not in runlevel 0 or 6. This means that if " "B or B cannot find out the current runlevel (for example, when " "I hasn't been initialized correctly and I " "does not exist) B will be called, which might not be what you " "want. Use the B<-f> flag if you want to do a hard B or B." msgstr "" #. type: Plain text #: ../halt.8:109 msgid "" "The B<-h> flag puts all hard disks in standby mode just before halt or " "power-off. Right now this is only implemented for IDE drives. A side effect " "of putting the drive in stand-by mode is that the write cache on the disk is " "flushed. This is important for IDE drives, since the kernel doesn't flush " "the write cache itself before power-off." msgstr "" #. type: Plain text #: ../halt.8:113 msgid "" "The B program uses I to find all IDE disk devices, " "which means that I needs to be mounted when B or B is " "called or the B<-h> switch will do nothing." msgstr "" #. type: Plain text #: ../halt.8:124 msgid "B(8), B(8)" msgstr "" #. type: TH #: ../init.8:20 #, no-wrap msgid "INIT" msgstr "" #. type: TH #: ../init.8:20 #, no-wrap msgid "29 Jul 2004" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../init.8:27 msgid "init, telinit - process control initialization" msgstr "" #. type: Plain text #: ../init.8:34 msgid "" "B [B< -a >] [B< -s >] [B< -b >] [ B<-z> I ] [B< 0123456Ss " ">]" msgstr "" #. type: Plain text #: ../init.8:37 msgid "B [B< --version >]" msgstr "" #. type: Plain text #: ../init.8:41 msgid "B [ B<-t> I ] [B< 0123456sSQqabcUu >]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../init.8:46 msgid "B [ B<-e> I[B<=>I] ]" msgstr "" #. {{{ init #. type: SS #: ../init.8:48 #, no-wrap msgid "Init" msgstr "" #. type: Plain text #: ../init.8:55 msgid "" "B is the parent of all processes. Its primary role is to create " "processes from a script stored in the file I (see " "B(5)). This file usually has entries which cause B to spawn " "Bs on each line that users can log in. It also controls autonomous " "processes required by any particular system." msgstr "" #. {{{ Runlevels #. type: SH #: ../init.8:57 #, no-wrap msgid "RUNLEVELS" msgstr "" #. type: Plain text #: ../init.8:66 msgid "" "A I is a software configuration of the system which allows only a " "selected group of processes to exist. The processes spawned by B for " "each of these runlevels are defined in the I file. B " "can be in one of eight runlevels: B<0\\(en6> and B (a.k.a. B). The " "runlevel is changed by having a privileged user run B, which sends " "appropriate signals to B, telling it which runlevel to change to." msgstr "" #. type: Plain text #: ../init.8:75 msgid "" "Runlevels B, B<0>, B<1>, and B<6> are reserved. Runlevel S is used to " "initialize the system on boot. When starting runlevel S (on boot) or " "runlevel 1 (switching from a multi-user runlevel) the system is entering " "``single-user mode'', after which the current runlevel is S. Runlevel 0 is " "used to halt the system; runlevel 6 is used to reboot the system." msgstr "" #. type: Plain text #: ../init.8:82 msgid "" "After booting through S the system automatically enters one of the " "multi-user runlevels 2 through 5, unless there was some problem that needs " "to be fixed by the administrator in single-user mode. Normally after " "entering single-user mode the administrator performs maintenance and then " "reboots the system." msgstr "" #. type: Plain text #: ../init.8:85 msgid "For more information, see the manpages for B(8) and B(5)." msgstr "" #. type: Plain text #: ../init.8:88 msgid "" "Runlevels 7-9 are also valid, though not really documented. This is because " "\"traditional\" Unix variants don't use them." msgstr "" #. }}} #. type: Plain text #: ../init.8:92 msgid "" "Runlevels I and I are the same. Internally they are aliases for the " "same runlevel." msgstr "" #. type: SH #: ../init.8:93 #, no-wrap msgid "BOOTING" msgstr "" #. type: Plain text #: ../init.8:100 msgid "" "After B is invoked as the last step of the kernel boot sequence, it " "looks for the file I to see if there is an entry of the type " "B (see B(5)). The B entry determines the " "initial runlevel of the system. If there is no such entry (or no " "I at all), a runlevel must be entered at the system console." msgstr "" #. type: Plain text #: ../init.8:103 msgid "" "Runlevel B or B initialize the system and do not require an " "I file." msgstr "" #. type: Plain text #: ../init.8:105 msgid "In single user mode, B is invoked on I." msgstr "" #. type: Plain text #: ../init.8:109 msgid "" "When entering single user mode, B initializes the consoles B " "settings to sane values. Clocal mode is set. Hardware speed and handshaking " "are not changed." msgstr "" #. type: Plain text #: ../init.8:114 msgid "" "When entering a multi-user mode for the first time, B performs the " "B and B entries to allow file systems to be mounted before " "users can log in. Then all entries matching the runlevel are processed." msgstr "" #. type: Plain text #: ../init.8:118 msgid "" "When starting a new process, B first checks whether the file " "I exists. If it does, it uses this script to start the " "process." msgstr "" #. type: Plain text #: ../init.8:122 msgid "" "Each time a child terminates, B records the fact and the reason it " "died in I and I, provided that these files " "exist." msgstr "" #. type: SH #: ../init.8:122 #, no-wrap msgid "CHANGING RUNLEVELS" msgstr "" #. type: Plain text #: ../init.8:132 msgid "" "After it has spawned all of the processes specified, B waits for one " "of its descendant processes to die, a powerfail signal, or until it is " "signaled by B to change the system's runlevel. When one of the " "above three conditions occurs, it re-examines the I file. New " "entries can be added to this file at any time. However, B still waits " "for one of the above three conditions to occur. To provide for an " "instantaneous response, the B or B command can wake up B " "to re-examine (reload) the I file." msgstr "" #. type: Plain text #: ../init.8:136 msgid "" "If B is not in single user mode and receives a powerfail signal " "(SIGPWR), it reads the file I. It then starts a command " "based on the contents of this file:" msgstr "" #. type: IP #: ../init.8:136 #, no-wrap msgid "F(AIL)" msgstr "" #. type: Plain text #: ../init.8:139 msgid "" "Power is failing, UPS is providing the power. Execute the B and " "B entries." msgstr "" #. type: IP #: ../init.8:139 #, no-wrap msgid "O(K)" msgstr "" #. type: Plain text #: ../init.8:141 msgid "The power has been restored, execute the B entries." msgstr "" #. type: IP #: ../init.8:141 #, no-wrap msgid "L(OW)" msgstr "" #. type: Plain text #: ../init.8:144 msgid "" "The power is failing and the UPS has a low battery. Execute the " "B entries." msgstr "" #. type: Plain text #: ../init.8:148 msgid "" "If I doesn't exist or contains anything else then the " "letters B, B or B, B will behave as if it has read the letter " "B." msgstr "" #. type: Plain text #: ../init.8:153 msgid "" "Usage of B and I is discouraged. Someone wanting " "to interact with B should use the I control channel - " "see the B(5) manual page for more documentation about this." msgstr "" #. }}} #. {{{ telinit #. type: Plain text #: ../init.8:165 msgid "" "When B is requested to change the runlevel, it sends the warning " "signal B to all processes that are undefined in the new runlevel. " "It then waits 3 seconds before forcibly terminating these processes via the " "B signal. Note that B assumes that all these processes (and " "their descendants) remain in the same process group which B originally " "created for them. If any process changes its process group affiliation it " "will not receive these signals. Such processes need to be terminated " "separately." msgstr "" #. type: SH #: ../init.8:165 #, no-wrap msgid "TELINIT" msgstr "" #. type: Plain text #: ../init.8:170 msgid "" "B is linked to B. It takes a one-character " "argument and signals B to perform the appropriate action. The " "following arguments serve as directives to B:" msgstr "" #. type: IP #: ../init.8:170 #, no-wrap msgid "B<0>, B<1>, B<2>, B<3>, B<4>, B<5> or B<6>" msgstr "" #. type: Plain text #: ../init.8:172 msgid "tell B to switch to the specified run level." msgstr "" #. type: IP #: ../init.8:172 #, no-wrap msgid "B, B, B" msgstr "" #. type: Plain text #: ../init.8:175 msgid "" "tell B to process only those B file entries having " "runlevel B, B or B." msgstr "" #. type: IP #: ../init.8:175 #, no-wrap msgid "B or B" msgstr "" #. type: Plain text #: ../init.8:177 msgid "tell B to re-examine the I file." msgstr "" #. type: IP #: ../init.8:177 #, no-wrap msgid "B or B" msgstr "" #. type: Plain text #: ../init.8:179 msgid "tell B to switch to single user mode." msgstr "" #. type: IP #: ../init.8:179 #, no-wrap msgid "B or B" msgstr "" #. type: Plain text #: ../init.8:184 msgid "" "tell B to re-execute itself (preserving the state). No re-examining of " "I file happens. Runlevel should be one of B " "otherwise request would be silently ignored." msgstr "" #. type: Plain text #: ../init.8:188 msgid "" "B can tell B how long it should wait between sending " "processes the B and B signals. The default is 3 seconds, " "but this can be changed with the B<-t> option." msgstr "" #. type: Plain text #: ../init.8:196 msgid "" "B tells B to change the environment for processes it " "spawns. The argument of B<-e> is either of the form I=I which " "sets variable I to value I, or of the form I (without an " "equality sign) which unsets variable I." msgstr "" #. type: Plain text #: ../init.8:199 msgid "B can be invoked only by users with appropriate privileges." msgstr "" #. }}} #. }}} #. type: Plain text #: ../init.8:206 msgid "" "The B binary checks if it is B or B by looking at its " "I; the real B's process id is always B<1>. From this it " "follows that instead of calling B one can also just use B " "instead as a shortcut." msgstr "" #. type: SH #: ../init.8:206 ../wall.1:63 #, no-wrap msgid "ENVIRONMENT" msgstr "" #. type: Plain text #: ../init.8:208 msgid "B sets the following environment variables for all its children:" msgstr "" #. type: IP #: ../init.8:208 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:210 msgid "I" msgstr "" #. type: IP #: ../init.8:210 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:212 msgid "" "As the name says. Useful to determine if a script runs directly from " "B." msgstr "" #. type: IP #: ../init.8:212 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:214 msgid "The current system runlevel." msgstr "" #. type: IP #: ../init.8:214 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:216 msgid "The previous runlevel (useful after a runlevel switch)." msgstr "" #. type: IP #: ../init.8:216 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:219 msgid "" "The system console. This is really inherited from the kernel; however if it " "is not set B will set it to I by default." msgstr "" #. type: SH #: ../init.8:219 #, no-wrap msgid "BOOTFLAGS" msgstr "" #. type: Plain text #: ../init.8:222 msgid "" "It is possible to pass a number of flags to B from the boot monitor " "(eg. LILO or GRUB). B accepts the following flags:" msgstr "" #. type: TP #: ../init.8:222 #, no-wrap msgid "B<-s, S, single>" msgstr "" #. type: Plain text #: ../init.8:227 msgid "" "Single user mode boot. In this mode I is examined and the " "bootup rc scripts are usually run before the single user mode shell is " "started." msgstr "" #. type: TP #: ../init.8:228 #, no-wrap msgid "B<1-5>" msgstr "" #. type: Plain text #: ../init.8:231 msgid "Runlevel to boot into." msgstr "" #. type: TP #: ../init.8:232 #, no-wrap msgid "B<-b, emergency>" msgstr "" #. type: Plain text #: ../init.8:236 msgid "" "Boot directly into a single user shell without running any other startup " "scripts." msgstr "" #. type: TP #: ../init.8:237 #, no-wrap msgid "B<-a, auto>" msgstr "" #. type: Plain text #: ../init.8:245 msgid "" "The LILO boot loader adds the word \"auto\" to the command line if it booted " "the kernel with the default command line (without user intervention). If " "this is found B sets the \"AUTOBOOT\" environment variable to " "\"yes\". Note that you cannot use this for any security measures - of course " "the user could specify \"auto\" or B<-a> on the command line manually." msgstr "" #. type: TP #: ../init.8:246 #, no-wrap msgid "B<-z >I" msgstr "" #. type: Plain text #: ../init.8:252 msgid "" "The argument to B<-z> is ignored. You can use this to expand the command " "line a bit, so that it takes some more space on the stack. B can then " "manipulate the command line so that B(1) shows the current runlevel." msgstr "" #. type: TP #: ../init.8:253 #, no-wrap msgid "B<--version>" msgstr "" #. type: Plain text #: ../init.8:259 msgid "" "This argument, when used on its own, displays the current version of B " "to the console/stdout. It is a quick way to determine which B software " "and version is being used. After the version information is displayed, " "B immediately exits with a return code of zero." msgstr "" #. type: SH #: ../init.8:260 #, no-wrap msgid "INTERFACE" msgstr "" #. type: Plain text #: ../init.8:266 msgid "" "B listens on a I in /dev, I, for messages. " "B uses this to communicate with B. The interface is not very " "well documented or finished. Those interested should study the I " "file in the I subdirectory of the B source code tar archive." msgstr "" #. type: SH #: ../init.8:266 #, no-wrap msgid "SIGNALS" msgstr "" #. type: Plain text #: ../init.8:268 msgid "Init reacts to several signals:" msgstr "" #. type: TP #: ../init.8:268 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:271 msgid "Has the same effect as B." msgstr "" #. type: TP #: ../init.8:272 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:276 msgid "" "On receipt of this signals, B closes and re-opens its control fifo, " "B. Useful for bootscripts when I is remounted." msgstr "" #. type: TP #: ../init.8:276 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:283 msgid "" "When B receives B, B closes and leaves the control " "fifo, B, closed. This may be used to make sure B is not " "holding open any files. However, it also prevents B from switching " "runlevels. Which means commands like shutdown no longer work. The fifo can " "be re-opened by sending B the B signal." msgstr "" #. type: TP #: ../init.8:283 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:287 msgid "" "Normally the kernel sends this signal to B when CTRL-ALT-DEL is " "pressed. It activates the I action." msgstr "" #. type: TP #: ../init.8:287 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../init.8:291 msgid "" "The kernel sends this signal when the I key is hit. It " "activates the I action." msgstr "" #. {{{ Conforming to #. type: SH #: ../init.8:292 #, no-wrap msgid "CONFORMING TO" msgstr "" #. }}} #. {{{ Files #. type: Plain text #: ../init.8:300 msgid "" "B is compatible with the System V init. It works closely together with " "the scripts in the directories I and I. " "If your system uses this convention, there should be a I file in the " "directory I explaining how these scripts work." msgstr "" #. type: SH #: ../init.8:300 ../initctl.5:143 ../initscript.5:65 ../inittab.5:271 #: ../last.1:114 ../readbootlog.1:48 ../shutdown.8:207 #, no-wrap msgid "FILES" msgstr "" #. type: Plain text #: ../init.8:308 #, no-wrap msgid "" "/etc/inittab\n" "/etc/initscript\n" "/dev/console\n" "/var/run/utmp\n" "/var/log/wtmp\n" "/run/initctl\n" msgstr "" #. }}} #. {{{ Warnings #. type: SH #: ../init.8:311 #, no-wrap msgid "WARNINGS" msgstr "" #. type: Plain text #: ../init.8:317 msgid "" "B assumes that processes and descendants of processes remain in the " "same process group which was originally created for them. If the processes " "change their group, B can't kill them and you may end up with two " "processes reading from one terminal line." msgstr "" #. }}} #. {{{ Diagnostics #. type: Plain text #: ../init.8:327 msgid "" "On a Debian system, entering runlevel 1 causes all processes to be killed " "except for kernel threads and the script that does the killing and other " "processes in its session. As a consequence of this, it isn't safe to return " "from runlevel 1 to a multi-user runlevel: daemons that were started in " "runlevel S and are needed for normal operation are no longer running. The " "system should be rebooted." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../init.8:337 msgid "" "If B finds that it is continuously respawning an entry more than 10 " "times in 2 minutes, it will assume that there is an error in the command " "string, generate an error message on the system console, and refuse to " "respawn this entry until either 5 minutes has elapsed or it receives a " "signal. This prevents it from eating up system resources when someone makes " "a typographical error in the I file or the program for the " "entry is removed." msgstr "" #. }}} #. {{{ See also #. type: Plain text #: ../init.8:346 msgid "" "E<.MT miquels@\\:cistron\\:.nl> Miquel van Smoorenburg E<.ME , initial " "manual page by> E<.MT u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> " "Michael Haardt E<.ME .>" msgstr "" #. type: Plain text #: ../init.8:356 msgid "" "B(1), B(1), B(1), B(8), B(8), " "B(1), B(5), B(5), B(5), B(5)" msgstr "" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "INITCTL" msgstr "" #. type: TH #: ../initctl.5:17 #, no-wrap msgid "April 13, 2018" msgstr "" #. type: TH #: ../initctl.5:17 ../initscript.5:18 ../inittab.5:20 #, no-wrap msgid "File Formats" msgstr "" #. type: Plain text #: ../initctl.5:20 msgid "initctl - /run/initctl is a named pipe which passes commands to SysV init" msgstr "" #. type: Plain text #: ../initctl.5:22 msgid "/run/initctl" msgstr "" #. type: Plain text #: ../initctl.5:28 msgid "" "This document describes the communication pipe set up by SysV B at " "I. This named pipe allows programs with the proper permissions " "(typically programs run by root have read+write access to the pipe) to send " "signals to the B program (PID 1)." msgstr "" #. type: Plain text #: ../initctl.5:32 msgid "" "The B manual page has, up until recently, simply stated that people " "wishing to understand how to send messages to B should read the init " "program's source code, but that is not usually practical." msgstr "" #. type: Plain text #: ../initctl.5:36 msgid "" "Messages sent to the pipe to talk to B must have a special format. " "This format is defined as a C structure and the technical break-down is " "presented here:" msgstr "" #. type: Plain text #: ../initctl.5:44 #, no-wrap msgid "" "/*\n" " * Because of legacy interfaces, \"runlevel\" and \"sleeptime\"\n" " * aren't in a separate struct in the union.\n" " *\n" " * The weird sizes are because init expects the whole\n" " * struct to be 384 bytes.\n" " */\n" msgstr "" #. type: Plain text #: ../initctl.5:55 #, no-wrap msgid "" "struct init_request {\n" " int magic; /* Magic number */\n" " int cmd; /* What kind of request */\n" " int runlevel; /* Runlevel to change to */\n" " int sleeptime; /* Time between TERM and KILL */\n" " union {\n" " struct init_request_bsd bsd;\n" " char data[368];\n" " } i;\n" "};\n" msgstr "" #. type: Plain text #: ../initctl.5:61 msgid "" "Let's go through the init_request structure one line at a time. The first " "variable, the \"magic\" number must be of the value 0x03091969. The B " "program then knows that only programs with root access which send this magic " "number are authorized to communicate with init." msgstr "" #. type: Plain text #: ../initctl.5:64 msgid "" "The I variable is a value in the range of 0-8 (currently). This I " "variable tells init what we want it to do. Here are the possible options:" msgstr "" #. type: Plain text #: ../initctl.5:66 msgid "1 - Set the current runlevel, specified by the runlevel variable." msgstr "" #. type: Plain text #: ../initctl.5:68 msgid "2 - The power will fail soon (probably low battery) prepare to shutdown." msgstr "" #. type: Plain text #: ../initctl.5:70 msgid "3 - The power is failing, do shutdown immediately." msgstr "" #. type: Plain text #: ../initctl.5:72 msgid "4 - The power is okay, cancel shutdown." msgstr "" #. type: Plain text #: ../initctl.5:75 #, no-wrap msgid "" "6 - Set an environment variable to a value to be specified in \n" " the I variable of this structure.\n" msgstr "" #. type: Plain text #: ../initctl.5:78 msgid "" "Other I options may be added to B later. For example, command " "values 0, 5 and 7 are defined but currently not implemented." msgstr "" #. type: Plain text #: ../initctl.5:80 msgid "The I variable will specify the runlevel to switch to (0-6)." msgstr "" #. type: Plain text #: ../initctl.5:84 msgid "" "The I variable is to be used when we want to tell B to " "change the time spent waiting between sending B and B " "during the shutdown process. Changing this at run time is not yet " "implemented." msgstr "" #. type: Plain text #: ../initctl.5:88 msgid "" "The I variable (in the union) can be used to pass misc data which init " "might need to process our request. For example, when setting environment " "variables." msgstr "" #. type: Plain text #: ../initctl.5:92 msgid "" "When setting an environment variable through B's I pipe, " "the data variable should have the format I=I. The string " "should be terminated with a NULL character." msgstr "" #. type: Plain text #: ../initctl.5:99 msgid "" "The following C code example shows how to send a set environment variable " "request to the B process using the I pipe. This example " "is simplified and skips the error checking. A more complete example can be " "found in the shutdown.c program's B() function." msgstr "" #. type: Plain text #: ../initctl.5:103 #, no-wrap msgid "" "struct init_request request; /* structure defined above */\n" "int fd; /* file descriptor for pipe */\n" msgstr "" #. type: Plain text #: ../initctl.5:108 #, no-wrap msgid "" "memset(&request, 0, sizeof(request)); /* initialize structure */\n" "request.magic = 0x03091969; /* magic number required */\n" "request.cmd = 6; /* 6 is to set a variable */\n" "sprintf(request.data, \"VARIABLE=VALUE\"); /* set VAR to VALUE in init " "*/\n" msgstr "" #. type: Plain text #: ../initctl.5:116 #, no-wrap msgid "" "if ((fd = open(INIT_FIFO, O_WRONLY)) E= 0) /* open pipe for writing */\n" "{ \n" " size_t s = sizeof(request); /* size of structure to write " "*/\n" " void *ptr = &request; /* temporary pointer */\n" " write(fd, ptr, s); /* send structure to the pipe " "*/\n" " close(fd); /* close the pipe when done */\n" "}\n" msgstr "" #. type: Plain text #: ../initctl.5:125 msgid "" "Usually the I pipe would only be used by low-level programs to " "request a power-related shutdown or change the runlevel, like B " "would do. Most of the time there is no need to talk to B directly, but " "this gives us an extendable approach so B can be taught how to learn " "more commands." msgstr "" #. type: Plain text #: ../initctl.5:130 msgid "" "The commands passed through the I pipe must be sent in a " "specific binary format and be of a specific length. Larger data structures " "or ones not using the proper format will be ignored. Typically, only root " "has the ability to write to the initctl pipe for security reasons." msgstr "" #. type: Plain text #: ../initctl.5:138 msgid "" "The I pipe can be closed by sending init (PID 1) the " "B signal. This closes the pipe and leaves it closed. This may be " "useful for making sure B is not keeping any files open. However, when " "the pipe is closed, B no longer receives signals, such as those sent " "by B(8) or B(8). In other words if we close the pipe, " "B cannot change its runlevel directly. The pipe may be re-opened by " "sending B (PID 1) the B signal." msgstr "" #. type: Plain text #: ../initctl.5:142 msgid "" "If the I pipe is closed then it may still be possible to bring " "down the system using the B(8) command's B<-n> flag, but this is " "not always clean and not recommended." msgstr "" #. type: Plain text #: ../initctl.5:146 msgid "/run/initctl /sbin/init" msgstr "" #. type: Plain text #: ../initctl.5:151 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com > Jesse Smith E<.ME>" msgstr "" #. type: Plain text #: ../initctl.5:152 msgid "B(8)" msgstr "" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "INITSCRIPT" msgstr "" #. type: TH #: ../initscript.5:18 #, no-wrap msgid "July 10, 2003" msgstr "" #. type: Plain text #: ../initscript.5:21 msgid "initscript - script that executes inittab commands" msgstr "" #. type: Plain text #: ../initscript.5:23 msgid "/bin/sh /etc/initscript id runlevels action process" msgstr "" #. type: Plain text #: ../initscript.5:28 msgid "" "When the shell script I is present, B will use it to " "execute the commands from I. This script can be used to set things " "like I and I default values for every process." msgstr "" #. type: Plain text #: ../initscript.5:31 msgid "" "This is a sample initscript, which might be installed on your system as " "I." msgstr "" #. type: Plain text #: ../initscript.5:42 #, no-wrap msgid "" "#\n" "# initscript Executed by init(8) for every program it\n" "# wants to spawn like this:\n" "#\n" "# /bin/sh /etc/initscript EidE ElevelE " "EactionE EprocessE\n" "#\n" msgstr "" #. type: Plain text #: ../initscript.5:48 #, no-wrap msgid "" " # Set umask to safe level, and enable core dumps.\n" " umask 022\n" " ulimit -c 2097151\n" " PATH=/bin:/sbin:/usr/bin:/usr/sbin\n" " export PATH\n" msgstr "" #. type: Plain text #: ../initscript.5:54 #, no-wrap msgid "" " # Increase the hard file descriptor limit for all processes\n" " # to 8192. The soft limit is still 1024, but any unprivileged\n" " # process can increase its soft limit up to the hard limit\n" " # with \"ulimit -Sn xxx\" (needs a 2.2.13 or later Linux kernel).\n" " ulimit -Hn 8192\n" msgstr "" #. type: Plain text #: ../initscript.5:57 #, no-wrap msgid "" " # Execute the program.\n" " eval exec \"$4\"\n" msgstr "" #. type: Plain text #: ../initscript.5:65 msgid "" "This script is not meant as startup script for daemons or services. It has " "nothing to do with a I style script. It's just a handler for " "things executed from B. Experimenting with this can make your " "system un(re)bootable." msgstr "" #. type: Plain text #: ../initscript.5:68 msgid "/etc/inittab, /etc/initscript." msgstr "" #. type: Plain text #: ../initscript.5:74 msgid "B(5), B(8)" msgstr "" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "INITTAB" msgstr "" #. type: TH #: ../inittab.5:20 #, no-wrap msgid "Dec 4, 2001" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../inittab.5:28 msgid "" "inittab - format of the inittab file used by the sysv-compatible init " "process" msgstr "" #. type: Plain text #: ../inittab.5:36 msgid "" "The B file describes which processes are started at bootup and " "during normal operation (e.g.\\& /etc/init.d/boot, /etc/init.d/rc, " "gettys...). B(8) distinguishes multiple I, each of which " "can have its own set of processes that are started. Valid runlevels are " "B<0>-B<6> plus B, B, and B for B entries. An entry in " "the B file has the following format:" msgstr "" #. type: Plain text #: ../inittab.5:39 msgid "I:I:I:I" msgstr "" #. {{{ id #. type: Plain text #: ../inittab.5:43 msgid "Lines beginning with `#' are ignored." msgstr "" #. type: IP #: ../inittab.5:43 #, no-wrap msgid "I" msgstr "" #. type: Plain text #: ../inittab.5:48 msgid "" "is a unique sequence of 1-4 characters which identifies an entry in " "B (for versions of sysvinit compiled with the I libc5 (E " "5.2.18) or a.out libraries the limit is 2 characters)." msgstr "" #. }}} #. {{{ runlevels #. type: Plain text #: ../inittab.5:55 msgid "" "Note: traditionally, for getty and other login processes, the value of the " "I field is kept the same as the suffix of the corresponding tty, e.g.\\& " "B<1> for B. Some ancient login accounting programs might expect this, " "though I can't think of any." msgstr "" #. type: IP #: ../inittab.5:55 #, no-wrap msgid "I" msgstr "" #. }}} #. {{{ action #. type: Plain text #: ../inittab.5:59 msgid "lists the runlevels for which the specified action should be taken." msgstr "" #. type: IP #: ../inittab.5:59 #, no-wrap msgid "I" msgstr "" #. }}} #. {{{ process #. type: Plain text #: ../inittab.5:63 msgid "describes which action should be taken." msgstr "" #. type: IP #: ../inittab.5:63 #, no-wrap msgid "I" msgstr "" #. type: Plain text #: ../inittab.5:70 msgid "" "specifies the process to be executed. If the process field starts with a " "`+' character, B will not do utmp and wtmp accounting for that " "process. This is needed for gettys that insist on doing their own utmp/wtmp " "housekeeping. This is also a historic bug. The length of this field is " "limited to 127 characters." msgstr "" #. '<>? #. type: Plain text #: ../inittab.5:77 msgid "" "Please note that including certain characters in the process field will " "result in B attempting to launch a shell to interpret the command " "contained in the process field. The characters which will trigger a shell " "are: B<~`!$^&*()=|\\{}[];>" msgstr "" #. type: Plain text #: ../inittab.5:84 msgid "" "On systems which do not have a shell to be launched or which do not wish to " "use a shell to interpret the process field, the process field can be " "prefixed with the @ symbol. The @ will be ignored and everything followed " "will be treated as a command to be launched, literally, by the B " "service." msgstr "" #. type: Plain text #: ../inittab.5:89 msgid "" "In cases where both a + and @ sign are to be used (to turn off logging and " "shell interpretation), place the + sign before the @ symbol. Both flags will " "be handled and then everything following the @ will be handled by B" msgstr "" #. type: Plain text #: ../inittab.5:98 msgid "" "The I field may contain multiple characters for different " "runlevels. For example, B<123> specifies that the process should be started " "in runlevels 1, 2, and 3. The I for B entries may " "contain an B, B, or B. The I field of B, " "B, and B entries are ignored." msgstr "" #. type: Plain text #: ../inittab.5:102 msgid "" "When the system runlevel is changed, any running processes that are not " "specified for the new runlevel are killed, first with \\s-2SIGTERM\\s0, then " "with \\s-2SIGKILL\\s0." msgstr "" #. {{{ respawn #. type: Plain text #: ../inittab.5:105 msgid "Valid actions for the I field are:" msgstr "" #. type: IP #: ../inittab.5:105 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ wait #. type: Plain text #: ../inittab.5:109 msgid "The process will be restarted whenever it terminates (e.g.\\& getty)." msgstr "" #. type: IP #: ../inittab.5:109 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ once #. type: Plain text #: ../inittab.5:115 msgid "" "The process will be started once when the specified runlevel is entered and " "B will wait for its termination." msgstr "" #. type: IP #: ../inittab.5:115 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ boot #. type: Plain text #: ../inittab.5:120 msgid "The process will be executed once when the specified runlevel is entered." msgstr "" #. type: IP #: ../inittab.5:120 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ bootwait #. type: Plain text #: ../inittab.5:125 msgid "" "The process will be executed during system boot. The I field is " "ignored." msgstr "" #. type: IP #: ../inittab.5:125 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ off #. type: Plain text #: ../inittab.5:132 msgid "" "The process will be executed during system boot, while B waits for its " "termination (e.g.\\& /etc/rc). The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:132 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ ondemand #. type: Plain text #: ../inittab.5:136 msgid "This does nothing." msgstr "" #. type: IP #: ../inittab.5:136 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ initdefault #. type: Plain text #: ../inittab.5:143 msgid "" "A process marked with an B runlevel will be executed whenever the " "specified B runlevel is called. However, no runlevel change will " "occur (B runlevels are `a', `b', and `c')." msgstr "" #. type: IP #: ../inittab.5:143 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ sysinit #. type: Plain text #: ../inittab.5:150 msgid "" "An B entry specifies the runlevel which should be entered after " "system boot. If none exists, B will ask for a runlevel on the " "console. The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:150 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ powerwait #. type: Plain text #: ../inittab.5:156 msgid "" "The process will be executed during system boot. It will be executed before " "any B or B< bootwait> entries. The I field is ignored." msgstr "" #. type: IP #: ../inittab.5:156 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ powerfail #. type: Plain text #: ../inittab.5:162 msgid "" "The process will be executed when the power goes down. B is usually " "informed about this by a process talking to a UPS connected to the " "computer. B will wait for the process to finish before continuing." msgstr "" #. type: IP #: ../inittab.5:162 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ powerokwait #. type: Plain text #: ../inittab.5:167 msgid "" "As for B, except that B does not wait for the process's " "completion." msgstr "" #. type: IP #: ../inittab.5:167 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ powerfailnow #. type: Plain text #: ../inittab.5:172 msgid "" "This process will be executed as soon as B is informed that the power " "has been restored." msgstr "" #. type: IP #: ../inittab.5:172 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ ctrlaltdel #. type: Plain text #: ../inittab.5:178 msgid "" "This process will be executed when B is told that the battery of the " "external UPS is almost empty and the power is failing (provided that the " "external UPS and the monitoring process are able to detect this condition)." msgstr "" #. type: IP #: ../inittab.5:178 #, no-wrap msgid "B" msgstr "" #. }}} #. {{{ kbrequest #. type: Plain text #: ../inittab.5:186 msgid "" "The process will be executed when B receives the B signal. " "This means that someone on the system console has pressed the " "B key combination. Typically one wants to execute some sort of " "B either to get into single-user level or to reboot the machine." msgstr "" #. type: IP #: ../inittab.5:186 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../inittab.5:190 msgid "" "The process will be executed when B receives a signal from the " "keyboard handler that a special key combination was pressed on the console " "keyboard." msgstr "" #. type: Plain text #: ../inittab.5:196 msgid "" "The documentation for this function is not complete yet; more documentation " "can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time " "of this writing). Basically you want to map some keyboard combination to the " "\"KeyboardSignal\" action. For example, to map Alt-Uparrow for this purpose " "use the following in your keymaps file:" msgstr "" #. type: Plain text #: ../inittab.5:199 msgid "alt keycode 103 = KeyboardSignal" msgstr "" #. type: Plain text #: ../inittab.5:206 msgid "This is an example of a inittab which resembles the old Linux inittab:" msgstr "" #. type: Plain text #: ../inittab.5:217 #, no-wrap msgid "" "# inittab for linux\n" "id:1:initdefault:\n" "rc::bootwait:/etc/rc\n" "1:1:respawn:/etc/getty 9600 tty1\n" "2:1:respawn:/etc/getty 9600 tty2\n" "3:1:respawn:/etc/getty 9600 tty3\n" "4:1:respawn:/etc/getty 9600 tty4\n" msgstr "" #. type: Plain text #: ../inittab.5:222 msgid "" "This inittab file executes I during boot and starts gettys on " "tty1-tty4." msgstr "" #. type: Plain text #: ../inittab.5:225 msgid "" "A more elaborate B with different runlevels (see the comments " "inside):" msgstr "" #. type: Plain text #: ../inittab.5:231 #, no-wrap msgid "" "# Level to run in\n" "id:2:initdefault:\n" msgstr "" #. type: Plain text #: ../inittab.5:234 #, no-wrap msgid "" "# Boot-time system configuration/initialization script.\n" "si::sysinit:/etc/init.d/rcS\n" msgstr "" #. type: Plain text #: ../inittab.5:237 #, no-wrap msgid "" "# What to do in single-user mode.\n" "~:S:wait:/sbin/sulogin\n" msgstr "" #. type: Plain text #: ../inittab.5:245 #, no-wrap msgid "" "# /etc/init.d executes the S and K scripts upon change\n" "# of runlevel.\n" "#\n" "# Runlevel 0 is halt.\n" "# Runlevel 1 is single-user.\n" "# Runlevels 2-5 are multi-user.\n" "# Runlevel 6 is reboot.\n" msgstr "" #. type: Plain text #: ../inittab.5:253 #, no-wrap msgid "" "l0:0:wait:/etc/init.d/rc 0\n" "l1:1:wait:/etc/init.d/rc 1\n" "l2:2:wait:/etc/init.d/rc 2\n" "l3:3:wait:/etc/init.d/rc 3\n" "l4:4:wait:/etc/init.d/rc 4\n" "l5:5:wait:/etc/init.d/rc 5\n" "l6:6:wait:/etc/init.d/rc 6\n" msgstr "" #. type: Plain text #: ../inittab.5:256 #, no-wrap msgid "" "# What to do at the \"3 finger salute\".\n" "ca::ctrlaltdel:/sbin/shutdown -t1 -h now\n" msgstr "" #. type: Plain text #: ../inittab.5:265 #, no-wrap msgid "" "# Runlevel 2,3: getty on virtual consoles\n" "# Runlevel 3: getty on terminal (ttyS0) and modem (ttyS1)\n" "1:23:respawn:/sbin/getty tty1 VC linux\n" "2:23:respawn:/sbin/getty tty2 VC linux\n" "3:23:respawn:/sbin/getty tty3 VC linux\n" "4:23:respawn:/sbin/getty tty4 VC linux\n" "S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320\n" "S1:3:respawn:/sbin/mgetty -x0 -D ttyS1\n" msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../inittab.5:275 msgid "/etc/inittab" msgstr "" #. }}} #. {{{ See also #. type: Plain text #: ../inittab.5:290 msgid "" "B was written by E<.MT miquels@\\:cistron\\:.nl> Miquel van " "Smoorenburg E<.ME .> This manual page was written by E<.MT " "lederer@\\:francium\\:.informatik\\:.uni-bonn\\:.de> Sebastian Lederer " "E<.ME> and modified by E<.MT " "u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de> Michael Haardt E<.ME .>" msgstr "" #. type: Plain text #: ../inittab.5:292 msgid "B(8), B(8)" msgstr "" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "KILLALL5" msgstr "" #. type: TH #: ../killall5.8:18 #, no-wrap msgid "04 Nov 2003" msgstr "" #. type: Plain text #: ../killall5.8:21 msgid "killall5 - send a signal to all processes" msgstr "" #. type: Plain text #: ../killall5.8:28 msgid "" "B B<-signalnumber> [B<-o> I[,I...]] [B<-o> " "I[,I...]...]" msgstr "" #. type: Plain text #: ../killall5.8:34 msgid "" "B is the SystemV B command. It sends a signal to all " "processes except kernel threads and the processes in its own session, so it " "won't kill the shell that is running the script it was called from. Its " "primary (only) use is in the B scripts found in the I " "directory." msgstr "" #. type: IP #: ../killall5.8:35 #, no-wrap msgid "B<-o> I" msgstr "" #. type: Plain text #: ../killall5.8:37 msgid "Tells B to omit processes with that process id." msgstr "" #. type: Plain text #: ../killall5.8:40 msgid "" "B can also be invoked as B(8), which is simply a (symbolic) " "link to the B program." msgstr "" #. type: Plain text #: ../killall5.8:44 msgid "" "The program return zero if it killed processes. It returns 2 if no process " "were killed, and 1 if it was unable to find any processes (I is " "missing)." msgstr "" #. type: Plain text #: ../killall5.8:48 msgid "B(8), B(8), B(8)" msgstr "" #. type: TH #: ../last.1:20 #, no-wrap msgid "LAST," msgstr "" #. type: TH #: ../last.1:20 #, no-wrap msgid "1" msgstr "" #. type: TH #: ../last.1:20 #, no-wrap msgid "Jul 31, 2004" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../last.1:27 msgid "last, lastb - show listing of last logged in users" msgstr "" #. type: Plain text #: ../last.1:37 msgid "" "B [B<-R>] [B<->I] [-B I] [B<-adFiowx>] [-B " "I] [-B I] [I] [I]" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../last.1:48 msgid "" "B [B<-R>] [B<->I] [-B I] [-B I] " "[B<-adFiowx>] [I] [I]" msgstr "" #. type: Plain text #: ../last.1:56 msgid "" "B searches back through the file B (or the file " "designated by the B<-f> flag) and displays a list of all users logged in " "(and out) since that file was created. Names of users and tty's can be " "given, in which case B will show only those entries matching the " "arguments. Names of ttys can be abbreviated, thus B is the same as " "B." msgstr "" #. type: Plain text #: ../last.1:61 msgid "" "When B catches a B signal (generated by the interrupt key, " "usually control-C) or a B signal (generated by the quit key, " "usually control-\\e), B will show how far it has searched through the " "file; in the case of the B signal B will then terminate." msgstr "" #. type: Plain text #: ../last.1:65 msgid "" "The pseudo user B logs in each time the system is rebooted. Thus " "B will show a log of all reboots since the log file was " "created." msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../last.1:70 msgid "" "B is the same as B, except that by default it shows a log of " "the file B, which contains all the bad login attempts." msgstr "" #. type: IP #: ../last.1:71 ../readbootlog.1:43 #, no-wrap msgid "B<-f> I" msgstr "" #. type: Plain text #: ../last.1:73 msgid "Tells B to use a specific file instead of I." msgstr "" #. type: IP #: ../last.1:73 #, no-wrap msgid "B<->I" msgstr "" #. type: Plain text #: ../last.1:75 msgid "This is a count telling B how many lines to show." msgstr "" #. type: IP #: ../last.1:75 #, no-wrap msgid "B<-n> I" msgstr "" #. type: Plain text #: ../last.1:77 msgid "The same." msgstr "" #. type: IP #: ../last.1:77 #, no-wrap msgid "B<-t> I" msgstr "" #. type: Plain text #: ../last.1:82 msgid "" "Display the state of logins as of the specified time. This is useful, e.g., " "to determine easily who was logged in at a particular time -- specify that " "time with B<-t> and look for \"still logged in\"." msgstr "" #. type: IP #: ../last.1:82 #, no-wrap msgid "B<-R>" msgstr "" #. type: Plain text #: ../last.1:84 msgid "Suppresses the display of the hostname field." msgstr "" #. {{{ -a #. type: IP #: ../last.1:84 ../logsave.8:40 ../shutdown.8:56 #, no-wrap msgid "B<-a>" msgstr "" #. type: Plain text #: ../last.1:87 msgid "" "Display the hostname in the last column. Useful in combination with the next " "flag." msgstr "" #. type: Plain text #: ../last.1:91 msgid "" "For non-local logins, Linux stores not only the host name of the remote host " "but its IP number as well. This option translates the IP number back into a " "hostname." msgstr "" #. type: IP #: ../last.1:91 ../shutdown.8:91 #, no-wrap msgid "B<-F>" msgstr "" #. type: Plain text #: ../last.1:93 msgid "Print full login and logout times and dates." msgstr "" #. type: Plain text #: ../last.1:96 msgid "" "This option is like B<-d> in that it displays the IP number of the remote " "host, but it displays the IP number in numbers-and-dots notation." msgstr "" #. type: IP #: ../last.1:96 #, no-wrap msgid "B<-l>" msgstr "" #. type: Plain text #: ../last.1:100 msgid "" "This option allows the display of usernames longer than 8 characters. This " "may mess up formatting in some programs and make the output wider than the " "standard 80 characters." msgstr "" #. type: IP #: ../last.1:100 ../utmpdump.1:33 #, no-wrap msgid "B<-o>" msgstr "" #. type: Plain text #: ../last.1:102 msgid "Read an old-type wtmp file (written by linux-libc5 applications)." msgstr "" #. type: Plain text #: ../last.1:104 msgid "Display full user and domain names in the output." msgstr "" #. type: IP #: ../last.1:104 ../mountpoint.1:40 ../pidof.8:63 #, no-wrap msgid "B<-x>" msgstr "" #. }}} #. type: Plain text #: ../last.1:107 msgid "Display the system shutdown entries and run level changes." msgstr "" #. {{{ Files #. type: Plain text #: ../last.1:114 msgid "" "The files I and I might not be found. The system only logs " "information in these files if they are present. This is a local " "configuration issue. If you want the files to be used, they can be created " "with a simple B(1) command (for example, B)." msgstr "" #. type: Plain text #: ../last.1:116 msgid "/var/log/wtmp" msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../last.1:120 msgid "/var/log/btmp" msgstr "" #. type: Plain text #: ../last.1:129 msgid "B(8), B(1), B(8)" msgstr "" #. type: TH #: ../logsave.8:5 #, no-wrap msgid "LOGSAVE" msgstr "" #. type: Plain text #: ../logsave.8:8 msgid "logsave - save the output of a command in a logfile" msgstr "" #. type: Plain text #: ../logsave.8:14 msgid "B [ B<-asv> ] I" msgstr "" #. type: Plain text #: ../logsave.8:27 msgid "" "The B program will execute I with the specified " "argument(s), and save a copy of its output to I. If the containing " "directory for I does not exist, B will accumulate the " "output in memory until it can be written out. A copy of the output will " "also be written to standard output." msgstr "" #. type: Plain text #: ../logsave.8:34 msgid "" "If I is a single hyphen ('-'), then instead of executing a " "program, B will take its input from standard input and save it in " "I." msgstr "" #. type: Plain text #: ../logsave.8:39 msgid "" "B is useful for saving the output of initial boot scripts until the " "I partition is mounted, so the output can be written to I." msgstr "" #. type: Plain text #: ../logsave.8:45 msgid "" "This option will cause the output to be appended to I, instead of " "replacing its current contents." msgstr "" #. type: Plain text #: ../logsave.8:53 msgid "" "This option will cause B to skip writing to the log file text which " "is bracketed with a control-A (ASCII 001 or Start of Header) and control-B " "(ASCII 002 or Start of Text). This allows progress bar information to be " "visible to the user on the console, while not being written to the log file." msgstr "" #. type: Plain text #: ../logsave.8:58 msgid "" "This option will make B to be more verbose in its output to the " "user." msgstr "" #. type: Plain text #: ../logsave.8:62 msgid "E<.MT tytso@mit\\:.edu> Theodore Ts'o E<.ME>" msgstr "" #. type: Plain text #: ../logsave.8:63 msgid "B(8)" msgstr "" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "MESG" msgstr "" #. type: TH #: ../mesg.1:20 #, no-wrap msgid "Feb 26, 2001" msgstr "" #. type: TH #: ../mesg.1:20 ../mountpoint.1:18 ../readbootlog.1:20 ../utmpdump.1:18 #: ../wall.1:18 #, no-wrap msgid "User Commands" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../mesg.1:27 msgid "mesg - control write access to your terminal" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../mesg.1:32 msgid "B [B|B]" msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../mesg.1:38 msgid "" "B controls the access to your terminal by others. It's typically used " "to allow or disallow other users to write to your terminal (see " "B(1))." msgstr "" #. type: IP #: ../mesg.1:39 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../mesg.1:41 msgid "Allow write access to your terminal." msgstr "" #. type: IP #: ../mesg.1:41 #, no-wrap msgid "B" msgstr "" #. type: Plain text #: ../mesg.1:43 msgid "Disallow write access to your terminal." msgstr "" #. }}} #. {{{ Notes #. type: Plain text #: ../mesg.1:48 msgid "" "If no option is given, B prints out the current access state of your " "terminal." msgstr "" #. type: Plain text #: ../mesg.1:53 msgid "" "B assumes that its standard input is connected to your terminal. That " "also means that if you are logged in multiple times, you can get/set the " "mesg status of other sessions by using redirection. For example \"mesg n " "E /dev/pts/46\"." msgstr "" #. type: Plain text #: ../mesg.1:62 msgid "B(1), B(1), B(1)" msgstr "" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "MOUNTPOINT" msgstr "" #. type: TH #: ../mountpoint.1:18 #, no-wrap msgid "Mar 15, 2004" msgstr "" #. type: Plain text #: ../mountpoint.1:21 msgid "mountpoint - see if a directory is a mountpoint" msgstr "" #. type: Plain text #: ../mountpoint.1:26 msgid "B [B<-q>] [B<-d>] I" msgstr "" #. type: Plain text #: ../mountpoint.1:30 msgid "B B<-x> I" msgstr "" #. type: Plain text #: ../mountpoint.1:32 msgid "B checks if the directory is a mountpoint." msgstr "" #. type: IP #: ../mountpoint.1:34 ../pidof.8:60 ../shutdown.8:107 #, no-wrap msgid "B<-q>" msgstr "" #. type: Plain text #: ../mountpoint.1:36 msgid "Be quiet - don't print anything." msgstr "" #. type: Plain text #: ../mountpoint.1:38 msgid "Print major/minor device number of the filesystem on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:40 msgid "Check Linux's I file to try to detect circular mount points." msgstr "" #. type: Plain text #: ../mountpoint.1:42 msgid "Print major/minor device number of the blockdevice on stdout." msgstr "" #. type: Plain text #: ../mountpoint.1:44 msgid "Zero if the directory is a mountpoint, non-zero if not." msgstr "" #. type: Plain text #: ../mountpoint.1:48 msgid "" "Symbolic links are not followed, except when the B<-x> option is used. To " "force following symlinks, add a trailing slash to the path of the directory." msgstr "" #. type: Plain text #: ../mountpoint.1:52 msgid "" "The name of the command is misleading when the B<-x> option is used, but the " "option is useful for comparing if a directory and a device match up, and " "there is no other command that can print the info easily." msgstr "" #. type: Plain text #: ../mountpoint.1:57 msgid "" "The mountpoint command fails when a directory is binded to one of its " "grandparents. For example, if /a/b/c/d is a mount point for /a/b then " "mountpoint will report /a/b/c/d is not a valid mount point. This is because " "both the original directory and its new mount point share the same inode and " "device number." msgstr "" #. type: Plain text #: ../mountpoint.1:66 msgid "" "The circular mount problem can be worked around on Linux systems by using " "theB<-p> flag to check the I file for references to the " "circular mount bind. When using the B<-p> flag, make sure to specify the " "full path (ie I and not just I). Also, B may " "still fail if there are spaces in the mount point's path, even when using " "the B<-p> flag because of the way B mangles the spaces in the " "path name. Of course, if the admin is using circular mount points with " "spaces in the name, there are bigger concerns." msgstr "" #. type: Plain text #: ../mountpoint.1:71 msgid "B(1)" msgstr "" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "PIDOF" msgstr "" #. type: TH #: ../pidof.8:18 #, no-wrap msgid "01 Sep 1998" msgstr "" #. type: Plain text #: ../pidof.8:21 msgid "pidof - find the process ID of a running program" msgstr "" #. type: Plain text #: ../pidof.8:36 msgid "" "B [B<-s>] [B<-c>] [B<-n>] [B<-x>] [B<-z>] [B<-o> " "I] [B<-o> I] [B<-d> I] " "I [I]" msgstr "" #. type: Plain text #: ../pidof.8:44 msgid "" "B finds the process id's (PIDs) of the named programs. It prints " "those id's on the standard output. This program is on some systems used in " "run-level change scripts, especially when the system has a I like " "I structure. In that case these scripts are located in I, " "where ? is the runlevel. If the system has a B(8) program " "that should be used instead." msgstr "" #. type: Plain text #: ../pidof.8:47 msgid "Single shot - this instructs the program to only return one I." msgstr "" #. type: Plain text #: ../pidof.8:51 msgid "" "Only return process PIDs that are running with the same root directory. " "This option is ignored for non-root users, as they will be unable to check " "the current root directory of processes they do not own." msgstr "" #. type: Plain text #: ../pidof.8:60 msgid "" "Avoid B(2) system function call on all binaries which are located on " "network based file systems like B. Instead of using this option the " "variable B may be set and exported." msgstr "" #. type: Plain text #: ../pidof.8:63 msgid "" "Do not display matched PIDs to standard out. Simply exit with a status of " "true or false to indicate whether a matching PID was found." msgstr "" #. type: Plain text #: ../pidof.8:66 msgid "" "Scripts too - this causes the program to also return process id's of shells " "running the named scripts." msgstr "" #. type: IP #: ../pidof.8:66 #, no-wrap msgid "B<-z>" msgstr "" #. type: Plain text #: ../pidof.8:73 msgid "" "Try to detect processes which are stuck in zombie (Z) status. Usually these " "processes are skipped as trying to deal with them can cause pidof or related " "tools to hang. Note: In the past pidof would ignore processes in the " "uninterruptable state (D), unless the B<-z> flag was specified. This is no " "longer the case. The B program will find and report processes in the " "D state whether B<-z> is specified or not." msgstr "" #. type: IP #: ../pidof.8:73 #, no-wrap msgid "-d I" msgstr "" #. type: Plain text #: ../pidof.8:76 msgid "" "Tells I to use I as an output separator if more than one PID is " "shown. The default separator is a space." msgstr "" #. type: IP #: ../pidof.8:76 #, no-wrap msgid "-o I" msgstr "" #. type: Plain text #: ../pidof.8:80 msgid "" "Tells I to omit processes with that process id. The special pid " "B<%PPID> can be used to name the parent process of the B program, in " "other words the calling shell or shell script." msgstr "" #. type: TP #: ../pidof.8:81 #, no-wrap msgid "B<0>" msgstr "" #. type: Plain text #: ../pidof.8:84 msgid "At least one program was found with the requested name." msgstr "" #. type: TP #: ../pidof.8:84 #, no-wrap msgid "B<1>" msgstr "" #. type: Plain text #: ../pidof.8:87 msgid "No program was found with the requested name." msgstr "" #. type: Plain text #: ../pidof.8:90 msgid "" "I is actually the same program as B(8); the program behaves " "according to the name under which it is called." msgstr "" #. type: Plain text #: ../pidof.8:98 msgid "" "When B is invoked with a full pathname to the program it should find " "the pid of, it is reasonably safe. Otherwise it is possible that it returns " "PIDs of running programs that happen to have the same name as the program " "you're after but are actually other programs. Note that the executable name " "of running processes is calculated with B(2), so symbolic links to " "executables will also match." msgstr "" #. type: Plain text #: ../pidof.8:103 msgid "" "Zombie processes or processes in disk sleep (states Z and D, respectively) " "are ignored, as attempts to access the stats of these will sometimes fail. " "The B<-z> flag (see above) tells B to try to detect these sleeping " "and zombie processes, at the risk of failing or hanging." msgstr "" #. type: Plain text #: ../pidof.8:110 msgid "B(8), B(8), B(8), B(8), B(8)" msgstr "" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "READBOOTLOG" msgstr "" #. type: TH #: ../readbootlog.1:20 #, no-wrap msgid "NOV 12, 2018" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../readbootlog.1:27 msgid "" "readbootlog - show contents of the boot log, stripping away control " "characters" msgstr "" #. type: Plain text #: ../readbootlog.1:31 msgid "B [B<-h>] [-B I]" msgstr "" #. }}} #. {{{ Options #. type: Plain text #: ../readbootlog.1:42 msgid "" "B is a tool for reading the boot log (by default " "I). The program strips away control characters and non-human " "readable contents from the log file. Output is dumped to the terminal where " "it can be piped or redirected to a file." msgstr "" #. type: Plain text #: ../readbootlog.1:45 msgid "Tells B to use a specific file instead of I." msgstr "" #. {{{ Files #. type: Plain text #: ../readbootlog.1:48 msgid "Displays a brief help message." msgstr "" #. }}} #. {{{ Author #. type: Plain text #: ../readbootlog.1:52 msgid "/var/log/boot" msgstr "" #. }}} #. {{{ See also #. type: Plain text #: ../readbootlog.1:58 msgid "E<.MT jsmith@\\:resonatingmedia\\:.com> Jesse Smith E<.ME>" msgstr "" #. type: Plain text #: ../readbootlog.1:59 msgid "B(8)" msgstr "" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "RUNLEVEL" msgstr "" #. type: TH #: ../runlevel.8:18 #, no-wrap msgid "May 27, 1997" msgstr "" #. type: Plain text #: ../runlevel.8:21 msgid "runlevel - find the previous and current system runlevel" msgstr "" #. type: Plain text #: ../runlevel.8:24 msgid "B [I]" msgstr "" #. type: Plain text #: ../runlevel.8:34 msgid "" "B reads the system I file (typically I) to " "locate the runlevel record, and then prints the previous and current system " "runlevel on its standard output, separated by a single space. If there is no " "previous system runlevel, the letter B will be printed instead." msgstr "" #. type: Plain text #: ../runlevel.8:42 msgid "" "If no I file exists, and if no runlevel record can be found in the " "I file, B prints the word B and exits " "with an error." msgstr "" #. type: Plain text #: ../runlevel.8:49 msgid "" "B can be used in I scripts as a substitute for the System-V " "B command. However, in newer versions of B(8) this " "information is also available in the environment variables B and " "B." msgstr "" #. {{{ utmp #. type: IP #: ../runlevel.8:51 #, no-wrap msgid "I" msgstr "" #. }}} #. type: Plain text #: ../runlevel.8:54 msgid "The name of the I file to read." msgstr "" #. type: Plain text #: ../runlevel.8:57 msgid "B(8), B(5)" msgstr "" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "SHUTDOWN" msgstr "" #. type: TH #: ../shutdown.8:20 #, no-wrap msgid "November 12, 2003" msgstr "" #. }}} #. {{{ Synopsis #. type: Plain text #: ../shutdown.8:27 msgid "shutdown - bring the system down" msgstr "" #. }}} #. {{{ Description #. type: Plain text #: ../shutdown.8:36 msgid "" "B [B<-akrhPHfFncqQ>] [B<-t> I] I