Update inotify.7 in LDP 3.68

[linuxjm/LDP_man-pages.git] / po4a / inotify / po / ja.po

# SOME DESCRIPTIVE TITLE
# Copyright (C) YEAR Free Software Foundation, Inc.
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: 2014-06-08 01:29+0900\n"
"PO-Revision-Date: 2014-06-13 21:10+0900\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. type: TH
#: build/C/man7/inotify.7:27
#, no-wrap
msgid "INOTIFY"
msgstr "INOTIFY"

#. type: TH
#: build/C/man7/inotify.7:27
#, no-wrap
msgid "2014-05-23"
msgstr "2014-05-23"

#. type: TH
#: build/C/man7/inotify.7:27 build/C/man2/inotify_add_watch.2:28
#: build/C/man2/inotify_init.2:29 build/C/man2/inotify_rm_watch.2:27
#: build/C/man2/fanotify_init.2:24 build/C/man2/fanotify_mark.2:24
#: build/C/man7/fanotify.7:25
#, no-wrap
msgid "Linux"
msgstr "Linux"

#. type: TH
#: build/C/man7/inotify.7:27 build/C/man2/inotify_add_watch.2:28
#: build/C/man2/inotify_init.2:29 build/C/man2/inotify_rm_watch.2:27
#: build/C/man2/fanotify_init.2:24 build/C/man2/fanotify_mark.2:24
#: build/C/man7/fanotify.7:25
#, no-wrap
msgid "Linux Programmer's Manual"
msgstr "Linux Programmer's Manual"

#. type: SH
#: build/C/man7/inotify.7:28 build/C/man2/inotify_add_watch.2:29
#: build/C/man2/inotify_init.2:30 build/C/man2/inotify_rm_watch.2:28
#: build/C/man2/fanotify_init.2:25 build/C/man2/fanotify_mark.2:25
#: build/C/man7/fanotify.7:26
#, no-wrap
msgid "NAME"
msgstr "名前"

#. type: Plain text
#: build/C/man7/inotify.7:30
msgid "inotify - monitoring filesystem events"
msgstr "inotify - ファイルシステムイベントを監視する"

#. type: SH
#: build/C/man7/inotify.7:30 build/C/man2/inotify_add_watch.2:35
#: build/C/man2/inotify_init.2:39 build/C/man2/inotify_rm_watch.2:36
#: build/C/man2/fanotify_init.2:33 build/C/man2/fanotify_mark.2:36
#: build/C/man7/fanotify.7:28
#, no-wrap
msgid "DESCRIPTION"
msgstr "説明"

#. type: Plain text
#: build/C/man7/inotify.7:38
msgid ""
"The I<inotify> API provides a mechanism for monitoring filesystem events.  "
"Inotify can be used to monitor individual files, or to monitor directories.  "
"When a directory is monitored, inotify will return events for the directory "
"itself, and for files inside the directory."
msgstr ""
"I<inotify> API はファイルシステムイベントを監視するための機構を提供する。 "
"inotify は個々のファイルやディレクトリを監視するのに使える。 ディレクトリを監"
"視する場合、inotify はディレクトリ自身と ディレクトリ内のファイルのイベントを"
"返す。"

#. type: Plain text
#: build/C/man7/inotify.7:40
msgid "The following system calls are used with this API:"
msgstr "この API では以下のシステムコールが使用される。"

#. type: IP
#: build/C/man7/inotify.7:40 build/C/man7/inotify.7:51
#: build/C/man7/inotify.7:64 build/C/man7/inotify.7:70
#: build/C/man7/inotify.7:73 build/C/man2/fanotify_init.2:242
#: build/C/man2/fanotify_mark.2:195 build/C/man2/fanotify_mark.2:201
#: build/C/man2/fanotify_mark.2:209 build/C/man2/fanotify_mark.2:215
#: build/C/man2/fanotify_mark.2:226 build/C/man2/fanotify_mark.2:308
#: build/C/man2/fanotify_mark.2:318 build/C/man2/fanotify_mark.2:324
#: build/C/man7/fanotify.7:490 build/C/man7/fanotify.7:499
#, no-wrap
msgid "*"
msgstr "*"

#. type: Plain text
#: build/C/man7/inotify.7:51
msgid ""
"B<inotify_init>(2)  creates an inotify instance and returns a file "
"descriptor referring to the inotify instance.  The more recent "
"B<inotify_init1>(2)  is like B<inotify_init>(2), but has a I<flags> argument "
"that provides access to some extra functionality."
msgstr ""
"B<inotify_init>(2)  は inotify インスタンスを作成し、inotify インスタンスを参"
"照する ファイルディスクリプタを返す。 より新しい B<inotify_init1>(2)  も "
"B<inotify_init>(2)  と同様だが、 こちらにはいくつかの追加の機能を利用するため"
"の I<flags> 引き数がある。"

#. type: Plain text
#: build/C/man7/inotify.7:64
msgid ""
"B<inotify_add_watch>(2)  manipulates the \"watch list\" associated with an "
"inotify instance.  Each item (\"watch\") in the watch list specifies the "
"pathname of a file or directory, along with some set of events that the "
"kernel should monitor for the file referred to by that pathname.  "
"B<inotify_add_watch>(2)  either creates a new watch item, or modifies an "
"existing watch.  Each watch has a unique \"watch descriptor\", an integer "
"returned by B<inotify_add_watch>(2)  when the watch is created."
msgstr ""
"B<inotify_add_watch>(2)  は inotify インスタンスに関連づけられた「監視対象 "
"(watch) リスト」を操作する。 監視対象リストの各アイテム (\"watch\") は、 ファ"
"イルまたはディレクトリのパス名と、 そのパス名で参照されるファイルに対して "
"カーネルが監視する複数のイベントの集合を指定する。 B<inotify_add_watch>(2)  "
"は新しい監視アイテムの作成や既存の監視対象の変更ができる。 各監視対象は一意の"
"「監視対象ディスクリプタ」を持つ。 これは監視対象を作成したときに "
"B<inotify_add_watch>(2)  から返される整数である。"

#. type: Plain text
#: build/C/man7/inotify.7:70
msgid ""
"When events occur for monitored files and directories, those events are made "
"available to the application as structured data that can be read from the "
"inotify file descriptor using B<read>(2)  (see below)."
msgstr ""
"監視しているファイルやディレクトリでイベントが起こると、 それらのイベントはア"
"プリケーションから inotify ファイルディスクリプタから B<read>(2) を使って構造"
"化データとして読み出すことができる (下記参照)。"

#. type: Plain text
#: build/C/man7/inotify.7:73
msgid "B<inotify_rm_watch>(2)  removes an item from an inotify watch list."
msgstr ""
"B<inotify_rm_watch>(2)  は inotify の監視対象リストからアイテムを削除する。"

#. type: Plain text
#: build/C/man7/inotify.7:80
msgid ""
"When all file descriptors referring to an inotify instance have been closed "
"(using B<close>(2)), the underlying object and its resources are freed for "
"reuse by the kernel; all associated watches are automatically freed."
msgstr ""
"inotify インスタンスを指している 全てのファイルディスクリプタが (B<close>(2) "
"を使って) クローズされた場合、 その下層にあるオブジェクトとそのリソースは、 "
"カーネルで再利用するために解放される。 関連が切られた監視対象は自動的に解放さ"
"れる。"

#. type: Plain text
#: build/C/man7/inotify.7:89
msgid ""
"With careful programming, an application can use inotify to efficiently "
"monitor and cache the state of a set of filesystem objects.  However, robust "
"applications should allow for the fact that bugs in the monitoring logic or "
"races of the kind described below may leave the cache inconsistent with the "
"filesystem state.  It is probably wise to to do some consistency checking, "
"and rebuild the cache when inconsistencies are detected."
msgstr ""
"注意深くプログラミングすることで、 アプリケーションは inotify を使ってファイ"
"ルシステムオブジェクトの集合の状態を効率的に監視しキャッシュしておくことがで"
"きる。 しかしながら、ロバストなアプリケーションでは、監視ロジックのバグや以下"
"に説明があるような種類の競合条件によりファイルシステムの状態とキャッシュが一"
"致しない状態になることがあるという事実も考慮に入れておくべきである。 おそらく"
"何らかの一貫性のチェックを行い、不一致が検出された場合にはキャッシュを再構築"
"するのが懸命だろう。"

#. type: SS
#: build/C/man7/inotify.7:89
#, no-wrap
msgid "Reading events from an inotify file descriptor"
msgstr "inotify ファイルディスクリプタからのイベントの読み出し"

#. type: Plain text
#: build/C/man7/inotify.7:102
msgid ""
"To determine what events have occurred, an application B<read>(2)s from the "
"inotify file descriptor.  If no events have so far occurred, then, assuming "
"a blocking file descriptor, B<read>(2)  will block until at least one event "
"occurs (unless interrupted by a signal, in which case the call fails with "
"the error B<EINTR>; see B<signal>(7))."
msgstr ""
"どのようなイベントが起こっていたかを知るには、 アプリケーションで inotify "
"ファイルディスクリプタを B<read>(2)  すればよい。 これまでに何もイベントが起"
"こっていない場合、 停止 (blocking) モードのファイルディスクリプタであれば、 "
"少なくとも 1 つのイベントが起こるまで B<read>(2)  は停止する (シグナルにより"
"割り込まれなかった場合。 シグナルによる割り込みがあった場合、呼び出しはエ"
"ラー B<EINTR> で失敗する。 B<signal>(7)  参照)。"

#. type: Plain text
#: build/C/man7/inotify.7:106
msgid ""
"Each successful B<read>(2)  returns a buffer containing one or more of the "
"following structures:"
msgstr ""
"B<read>(2)  が成功すると、以下の構造体を 1 つ以上含むバッファが返される:"

#.  FIXME . The type of the 'wd' field should probably be "int32_t".
#.  I submitted a patch to fix this.  See the LKML thread
#.  "[patch] Fix type errors in inotify interfaces", 18 Nov 2008
#.  Glibc bug filed: http://sources.redhat.com/bugzilla/show_bug.cgi?id=7040
#. type: Plain text
#: build/C/man7/inotify.7:121
#, no-wrap
msgid ""
"struct inotify_event {\n"
"    int      wd;       /* Watch descriptor */\n"
"    uint32_t mask;     /* Mask of events */\n"
"    uint32_t cookie;   /* Unique cookie associating related\n"
"                          events (for rename(2)) */\n"
"    uint32_t len;      /* Size of I<name> field */\n"
"    char     name[];   /* Optional null-terminated name */\n"
"};\n"
msgstr ""
"struct inotify_event {\n"
"    int      wd;       /* 監視対象ディスクリプタ */\n"
"    uint32_t mask;     /* イベントのマスク */\n"
"    uint32_t cookie;   /* 関連するイベント群を関連づける\n"
"                          一意なクッキー (rename(2) 用) */\n"
"    uint32_t len;      /* \\(aqname\\(aq フィールドのサイズ */\n"
"    char     name[];   /* ヌルで終端された任意の名前 */\n"
"};\n"

#. type: Plain text
#: build/C/man7/inotify.7:128
msgid ""
"I<wd> identifies the watch for which this event occurs.  It is one of the "
"watch descriptors returned by a previous call to B<inotify_add_watch>(2)."
msgstr ""
"I<wd> はイベント発生の監視対象を指定する。 これは、前もって行われた "
"B<inotify_add_watch>(2)  呼び出しで返された監視対象ディスクリプタのうちの 1 "
"つである。"

#. type: Plain text
#: build/C/man7/inotify.7:131
msgid ""
"I<mask> contains bits that describe the event that occurred (see below)."
msgstr ""
"I<mask> には発生したイベント (下記参照) を記述するためのビットが含まれる。"

#. type: Plain text
#: build/C/man7/inotify.7:143
msgid ""
"I<cookie> is a unique integer that connects related events.  Currently this "
"is used only for rename events, and allows the resulting pair of "
"B<IN_MOVED_FROM> and B<IN_MOVED_TO> events to be connected by the "
"application.  For all other event types, I<cookie> is set to 0."
msgstr ""
"I<cookie> は関連するイベントを関連づけるための一意な整数である。\n"
"現在のところ、この値は rename イベントに対してのみ使われており、\n"
"結果のペアである B<IN_MOVED_FROM> と B<IN_MOVED_TO> イベントを\n"
"アプリケーションで関連づけることができる。\n"
"他のイベント種別の場合には、 I<cookie> は 0 に設定する。"

#. type: Plain text
#: build/C/man7/inotify.7:152
msgid ""
"The I<name> field is present only when an event is returned for a file "
"inside a watched directory; it identifies the file pathname relative to the "
"watched directory.  This pathname is null-terminated, and may include "
"further null bytes (\\(aq\\e0\\(aq) to align subsequent reads to a suitable "
"address boundary."
msgstr ""
"I<name> フィールドは監視しているディレクトリ内のファイルに対して イベントが返"
"される場合のためにだけ存在する。 監視するディレクトリからのファイルの相対パス"
"名を表す。 このパス名はヌルで終端され、 その後の読み込みで適切なアドレス境界"
"に調整するために、 さらにヌルバイト (\\(aq\\e0\\(aq) が含まれる場合もある。"

#. type: Plain text
#: build/C/man7/inotify.7:162
msgid ""
"The I<len> field counts all of the bytes in I<name>, including the null "
"bytes; the length of each I<inotify_event> structure is thus I<sizeof(struct "
"inotify_event)+len>."
msgstr ""
"I<len> フィールドはヌルバイトを含む I<name> の全てのバイト数を表す。\n"
"よって、 I<inotify_event> 構造体のサイズは \n"
"I<sizeof(struct inotify_event)+len> である。"

#. type: Plain text
#: build/C/man7/inotify.7:173
msgid ""
"The behavior when the buffer given to B<read>(2)  is too small to return "
"information about the next event depends on the kernel version: in kernels "
"before 2.6.21, B<read>(2)  returns 0; since kernel 2.6.21, B<read>(2)  fails "
"with the error B<EINVAL>.  Specifying a buffer of size"
msgstr ""
"B<read>(2) に渡されたバッファが小さすぎて次のイベントに関する情報を返せ\n"
"ない場合の動作はカーネルのバージョンにより異なる。 2.6.21 より前のカー\n"
"ネルでは、 B<read>(2) は 0 を返す。 2.6.21 以降のカーネルでは、\n"
"B<read>(2) はエラー B<EINVAL> で失敗する。\n"
"バッファサイズとして"

#. type: Plain text
#: build/C/man7/inotify.7:175
#, no-wrap
msgid "    sizeof(struct inotify_event) + NAME_MAX + 1\n"
msgstr "    sizeof(struct inotify_event) + NAME_MAX + 1\n"

#. type: Plain text
#: build/C/man7/inotify.7:177
msgid "will be sufficient to read at least one event."
msgstr "を指定すれば、少なくとも 1 イベントで読み出しを行うには十分である。"

#. type: SS
#: build/C/man7/inotify.7:177
#, no-wrap
msgid "inotify events"
msgstr "inotify イベント"

#. type: Plain text
#: build/C/man7/inotify.7:197
msgid ""
"The B<inotify_add_watch>(2)  I<mask> argument and the I<mask> field of the "
"I<inotify_event> structure returned when B<read>(2)ing an inotify file "
"descriptor are both bit masks identifying inotify events.  The following "
"bits can be specified in I<mask> when calling B<inotify_add_watch>(2)  and "
"may be returned in the I<mask> field returned by B<read>(2):"
msgstr ""
"B<inotify_add_watch>(2)  の I<mask> 引き数と、inotify ファイル構造体を "
"B<read>(2)  したときに返される I<inotify_event> 構造体の I<mask> フィールド"
"は、ともに inotify イベントを識別するための ビットマスクである。 以下のビット"
"が B<inotify_add_watch>(2)  を呼ぶときの I<mask> に指定可能であり、 "
"B<read>(2)  で返される I<mask> フィールドで返される:"

#. type: TP
#: build/C/man7/inotify.7:198
#, no-wrap
msgid "B<IN_ACCESS> (*)"
msgstr "B<IN_ACCESS> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:203
msgid "File was accessed (e.g., B<read>(2), B<execve>(2))."
msgstr "(B<read>(2), B<execve>(2) などで) ファイルがアクセスされた。"

#. type: TP
#: build/C/man7/inotify.7:203
#, no-wrap
msgid "B<IN_ATTRIB> (*)"
msgstr "B<IN_ATTRIB> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:218
msgid ""
"Metadata changed\\(emfor example, permissions (e.g., B<chmod>(2)), "
"timestamps (e.g., B<utimensat>(2)), extended attributes (B<setxattr>(2)), "
"link count (since Linux 2.6.25; e.g., for the target of B<link>(2)  and for "
"B<unlink>(2)), and user/group ID (e.g., B<chown>(2))."
msgstr ""
"メタデータが変更された。 メタデータとは、例えば、アクセス許可 (B<chmod>(2))、"
"タイムスタンプ (B<utimensat>(2) など)、拡張属性 (B<setxattr>(2))、 リンクカウ"
"ント (Linux 2.6.25 以降; B<link>(2) のリンク先や B<unlink>(2) など)、ユー"
"ザー/グループ ID (B<chown>(2) など) などである。"

#. type: TP
#: build/C/man7/inotify.7:218
#, no-wrap
msgid "B<IN_CLOSE_WRITE> (*)"
msgstr "B<IN_CLOSE_WRITE> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:221
msgid "File opened for writing was closed."
msgstr "書き込みのためにオープンされたファイルがクローズされた。"

#. type: TP
#: build/C/man7/inotify.7:221
#, no-wrap
msgid "B<IN_CLOSE_NOWRITE> (*)"
msgstr "B<IN_CLOSE_NOWRITE> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:224
msgid "File not opened for writing was closed."
msgstr "書き込み以外のためにオープンされたファイルがクローズされた。"

#. type: TP
#: build/C/man7/inotify.7:224
#, no-wrap
msgid "B<IN_CREATE> (*)"
msgstr "B<IN_CREATE> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:234
msgid ""
"File/directory created in watched directory (e.g., B<open>(2)  B<O_CREAT>, "
"B<mkdir>(2), B<link>(2), B<symlink>(2), B<bind>(2)  on a UNIX domain socket)."
msgstr ""
"監視対象ディレクトリ内でファイルやディレクトリが作成された (B<open>(2)  "
"B<O_CREAT>, B<mkdir>(2), B<link>(2), B<symlink>(2), UNIX ドメインソケットに対"
"する B<bind>(2) など)。"

#. type: TP
#: build/C/man7/inotify.7:234
#, no-wrap
msgid "B<IN_DELETE> (*)"
msgstr "B<IN_DELETE> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:237
msgid "File/directory deleted from watched directory."
msgstr "監視対象ディレクトリ内でファイルやディレクトリが削除された。"

#. type: TP
#: build/C/man7/inotify.7:237
#, no-wrap
msgid "B<IN_DELETE_SELF>"
msgstr "B<IN_DELETE_SELF>"

#. type: Plain text
#: build/C/man7/inotify.7:248
msgid ""
"Watched file/directory was itself deleted.  (This event also occurs if an "
"object is moved to another filesystem, since B<mv>(1)  in effect copies the "
"file to the other filesystem and then deletes it from the original "
"filesystem.)  In addition, an B<IN_IGNORED> event will subsequently be "
"generated for the watch descriptor."
msgstr ""
"監視対象のファイルやディレクトリ自身が削除あれた。 (このイベントはオブジェク"
"トが別のファイルシステムに移動された場合にも発生する。 B<mv>(1) は実際には別"
"のファイルシステムにファイルをコピーした後、元のファイルシステムからそのファ"
"イルを削除するからである。) また、 結果的に監視ディスクリプタに対して "
"B<IN_IGNORED> イベントも生成される。"

#. type: TP
#: build/C/man7/inotify.7:248
#, no-wrap
msgid "B<IN_MODIFY> (*)"
msgstr "B<IN_MODIFY> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:253
msgid "File was modified (e.g., B<write>(2), B<truncate>(2))."
msgstr "ファイルが変更された (B<write>(2), B<truncate>(2) など)。"

#. type: TP
#: build/C/man7/inotify.7:253
#, no-wrap
msgid "B<IN_MOVE_SELF>"
msgstr "B<IN_MOVE_SELF>"

#. type: Plain text
#: build/C/man7/inotify.7:256
msgid "Watched file/directory was itself moved."
msgstr "監視対象のディレクトリまたはファイル自身が移動された。"

#. type: TP
#: build/C/man7/inotify.7:256
#, no-wrap
msgid "B<IN_MOVED_FROM> (*)"
msgstr "B<IN_MOVED_FROM> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:260
msgid ""
"Generated for the directory containing the old filename when a file is "
"renamed."
msgstr ""
"ファイル名の変更を行った際に変更前のファイル名が含まれるディレクトリに対して"
"生成される。"

#. type: TP
#: build/C/man7/inotify.7:260
#, no-wrap
msgid "B<IN_MOVED_TO> (*)"
msgstr "B<IN_MOVED_TO> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:264
msgid ""
"Generated for the directory containing the new filename when a file is "
"renamed."
msgstr ""
"ファイル名の変更を行った際に新しいファイル名が含まれるディレクトリに対して生"
"成される。"

#. type: TP
#: build/C/man7/inotify.7:264
#, no-wrap
msgid "B<IN_OPEN> (*)"
msgstr "B<IN_OPEN> (*)"

#. type: Plain text
#: build/C/man7/inotify.7:267
msgid "File was opened."
msgstr "ファイルがオープンされた。"

#. type: Plain text
#: build/C/man7/inotify.7:276
msgid ""
"When monitoring a directory, the events marked with an asterisk (*) above "
"can occur for files in the directory, in which case the I<name> field in the "
"returned I<inotify_event> structure identifies the name of the file within "
"the directory."
msgstr ""
"ディレクトリを監視する場合、 上記でアスタリスク (*) を付けたイベントは、 その"
"ディレクトリ内のファイルに対して発生する。 このとき I<inotify_event> 構造体で"
"返される I<name> フィールドは、ディレクトリ内のファイル名を表す。"

#. type: Plain text
#: build/C/man7/inotify.7:284
msgid ""
"The B<IN_ALL_EVENTS> macro is defined as a bit mask of all of the above "
"events.  This macro can be used as the I<mask> argument when calling "
"B<inotify_add_watch>(2)."
msgstr ""
"B<IN_ALL_EVENTS> マクロは上記のイベント全てのマスクとして定義される。 このマ"
"クロは B<inotify_add_watch>(2)  を呼び出すときの I<mask> 引き数として使える。"

#. type: Plain text
#: build/C/man7/inotify.7:286
msgid "Two additional convenience macros are defined:"
msgstr "以下の 2 つの便利なマクロが定義されている。"

#. type: TP
#: build/C/man7/inotify.7:287
#, no-wrap
msgid "B<IN_MOVE>"
msgstr "B<IN_MOVE>"

#. type: Plain text
#: build/C/man7/inotify.7:291
msgid "Equates to B<IN_MOVED_FROM | IN_MOVED_TO>."
msgstr "B<IN_MOVED_FROM | IN_MOVED_TO> と等価。"

#. type: TP
#: build/C/man7/inotify.7:291
#, no-wrap
msgid "B<IN_CLOSE>"
msgstr "B<IN_CLOSE>"

#. type: Plain text
#: build/C/man7/inotify.7:295
msgid "Equates to B<IN_CLOSE_WRITE | IN_CLOSE_NOWRITE>."
msgstr "B<IN_CLOSE_WRITE | IN_CLOSE_NOWRITE> と等価。"

#. type: Plain text
#: build/C/man7/inotify.7:301
msgid ""
"The following further bits can be specified in I<mask> when calling "
"B<inotify_add_watch>(2):"
msgstr ""
"その他にも以下のビットを B<inotify_add_watch>(2)  を呼ぶときの I<mask> に指定"
"できる:"

#. type: TP
#: build/C/man7/inotify.7:302
#, no-wrap
msgid "B<IN_DONT_FOLLOW> (since Linux 2.6.15)"
msgstr "B<IN_DONT_FOLLOW> (Linux 2.6.15 以降)"

#. type: Plain text
#: build/C/man7/inotify.7:307
msgid "Don't dereference I<pathname> if it is a symbolic link."
msgstr ""
"I<pathname> がシンボリックリンクである場合に辿らない。 (Linux 2.6.15 以降)"

#. type: TP
#: build/C/man7/inotify.7:307
#, no-wrap
msgid "B<IN_EXCL_UNLINK> (since Linux 2.6.36)"
msgstr "B<IN_EXCL_UNLINK> (Linux 2.6.36 以降)"

#.  commit 8c1934c8d70b22ca8333b216aec6c7d09fdbd6a6
#. type: Plain text
#: build/C/man7/inotify.7:323
msgid ""
"By default, when watching events on the children of a directory, events are "
"generated for children even after they have been unlinked from the "
"directory.  This can result in large numbers of uninteresting events for "
"some applications (e.g., if watching I</tmp>, in which many applications "
"create temporary files whose names are immediately unlinked).  Specifying "
"B<IN_EXCL_UNLINK> changes the default behavior, so that events are not "
"generated for children after they have been unlinked from the watched "
"directory."
msgstr ""
"デフォルトでは、あるディレクトリの子ファイルに関するイベントを監視 (watch) し"
"た際、ディレクトリからその子ファイルが削除 (unlink) された場合であってもその"
"子ファイルに対してイベントが生成される。このことは、アプリケーションによって"
"はあまり興味のないイベントが大量に発生することにつながる (例えば、I</tmp> を"
"監視している場合、たくさんのアプリケーションが、すぐにその名前が削除される一"
"時ファイルをそのディレクトリに作成する)。 B<IN_EXCL_UNLINK> を指定するとこの"
"デフォルトの動作を変更でき、監視対象のディレクトリから子ファイルが削除された"
"後に子ファイルに関するイベントが生成されなくなる。"

#. type: TP
#: build/C/man7/inotify.7:323
#, no-wrap
msgid "B<IN_MASK_ADD>"
msgstr "B<IN_MASK_ADD>"

#. type: Plain text
#: build/C/man7/inotify.7:327
msgid ""
"Add (OR) events to watch mask for this pathname if it already exists "
"(instead of replacing mask)."
msgstr ""
"I<pathname> に対する監視マスクが既に存在する場合、 (マスクの置き換えではな"
"く) イベントを追加 (OR) する。"

#. type: TP
#: build/C/man7/inotify.7:327
#, no-wrap
msgid "B<IN_ONESHOT>"
msgstr "B<IN_ONESHOT>"

#. type: Plain text
#: build/C/man7/inotify.7:333
msgid "Monitor I<pathname> for one event, then remove from watch list."
msgstr ""
"1 つのイベントについて I<pathname> を監視し、 イベントが発生したら監視対象リ"
"ストから削除する。"

#. type: TP
#: build/C/man7/inotify.7:333
#, no-wrap
msgid "B<IN_ONLYDIR> (since Linux 2.6.15)"
msgstr "B<IN_ONLYDIR> (Linux 2.6.15 以降)"

#. type: Plain text
#: build/C/man7/inotify.7:338
msgid "Only watch I<pathname> if it is a directory."
msgstr "I<pathname> がディレクトリの場合にのみ監視する。"

#. type: Plain text
#: build/C/man7/inotify.7:344
msgid ""
"The following bits may be set in the I<mask> field returned by B<read>(2):"
msgstr "以下のビットが B<read>(2)  で返される I<mask> フィールドに設定される:"

#. type: TP
#: build/C/man7/inotify.7:345
#, no-wrap
msgid "B<IN_IGNORED>"
msgstr "B<IN_IGNORED>"

#. type: Plain text
#: build/C/man7/inotify.7:351
msgid ""
"Watch was removed explicitly (B<inotify_rm_watch>(2))  or automatically "
"(file was deleted, or filesystem was unmounted).  See also BUGS."
msgstr ""
"監視対象が (B<inotify_rm_watch>(2) により) 明示的に 削除された。もしくは "
"(ファイルの削除、またはファイル システムのアンマウントにより) 自動的に削除さ"
"れた。「バグ」も参照のこと。"

#. type: TP
#: build/C/man7/inotify.7:351
#, no-wrap
msgid "B<IN_ISDIR>"
msgstr "B<IN_ISDIR>"

#. type: Plain text
#: build/C/man7/inotify.7:354
msgid "Subject of this event is a directory."
msgstr "このイベントの対象がディレクトリである。"

#. type: TP
#: build/C/man7/inotify.7:354
#, no-wrap
msgid "B<IN_Q_OVERFLOW>"
msgstr "B<IN_Q_OVERFLOW>"

#. type: Plain text
#: build/C/man7/inotify.7:359
msgid "Event queue overflowed (I<wd> is -1 for this event)."
msgstr "イベントキューが溢れた (このイベントの場合、I<wd> は -1 である)。"

#. type: TP
#: build/C/man7/inotify.7:359
#, no-wrap
msgid "B<IN_UNMOUNT>"
msgstr "B<IN_UNMOUNT>"

#. type: Plain text
#: build/C/man7/inotify.7:365
msgid ""
"Filesystem containing watched object was unmounted.  In addition, an "
"B<IN_IGNORED> event will subsequently be generated for the watch descriptor."
msgstr ""
"監視対象オブジェクトを含むファイルシステムがアンマウントされた。さらに、この"
"監視対象ディスクリプタに対して B<IN_IGNORED> イベントが生成される。"

#. type: SS
#: build/C/man7/inotify.7:366
#, no-wrap
msgid "Examples"
msgstr "例"

#. type: Plain text
#: build/C/man7/inotify.7:374
msgid ""
"Suppose an application is watching the directory I<dir> and the file I<dir/"
"myfile> for all events.  The examples below show some events that will be "
"generated for these two objects."
msgstr ""
"アプリケーションがディレクトリ I<dir> とファイル I<dir/myfile> のすべてのイベ"
"ントを監視しているとする。 以下に、これらの 2 つのオブジェクトに対して生成さ"
"れるイベントの例を示す。"

#. type: TP
#: build/C/man7/inotify.7:375
#, no-wrap
msgid "fd = open(\"dir/myfile\", O_RDWR);"
msgstr "fd = open(\"dir/myfile\", O_RDWR);"

#. type: Plain text
#: build/C/man7/inotify.7:383
msgid "Generates B<IN_OPEN> events for both I<dir> and I<dir/myfile>."
msgstr ""
"I<dir> と I<dir/myfile> の両方に対して B<IN_OPEN> イベントが生成される。"

#. type: TP
#: build/C/man7/inotify.7:383
#, no-wrap
msgid "read(fd, buf, count);"
msgstr "read(fd, buf, count);"

#. type: Plain text
#: build/C/man7/inotify.7:391
msgid "Generates B<IN_ACCESS> events for both I<dir> and I<dir/myfile>."
msgstr ""
"I<dir> と I<dir/myfile> の両方に対して B<IN_ACCESS> イベントが生成される"

#. type: TP
#: build/C/man7/inotify.7:391
#, no-wrap
msgid "write(fd, buf, count);"
msgstr "write(fd, buf, count);"

#. type: Plain text
#: build/C/man7/inotify.7:399
msgid "Generates B<IN_MODIFY> events for both I<dir> and I<dir/myfile>."
msgstr ""
"I<dir> と I<dir/myfile> の両方に対して B<IN_MODIFY> イベントが生成される"

#. type: TP
#: build/C/man7/inotify.7:399
#, no-wrap
msgid "fchmod(fd, mode);"
msgstr "fchmod(fd, mode);"

#. type: Plain text
#: build/C/man7/inotify.7:407
msgid "Generates B<IN_ATTRIB> events for both I<dir> and I<dir/myfile>."
msgstr ""
"I<dir> と I<dir/myfile> の両方に対して B<IN_ATTRIB> イベントが生成される"

#. type: TP
#: build/C/man7/inotify.7:407
#, no-wrap
msgid "close(fd);"
msgstr "close(fd);"

#. type: Plain text
#: build/C/man7/inotify.7:415
msgid "Generates B<IN_CLOSE_WRITE> events for both I<dir> and I<dir/myfile>."
msgstr ""
"I<dir> と I<dir/myfile> の両方に対して B<IN_CLOSE_WRITE> イベントが生成される"

#. type: Plain text
#: build/C/man7/inotify.7:424
msgid ""
"Suppose an application is watching the directories I<dir1> and I<dir2>, and "
"the file I<dir1/myfile>.  The following examples show some events that may "
"be generated."
msgstr ""
"アプリケーションがディレクトリ I<dir1> と I<dir2>、およびファイル I<dir1/"
"myfile> を監視しているとする。 以下に生成されるイベントの例を示す。"

#. type: TP
#: build/C/man7/inotify.7:425
#, no-wrap
msgid "link(\"dir1/myfile\", \"dir2/new\");"
msgstr "link(\"dir1/myfile\", \"dir2/new\");"

#. type: Plain text
#: build/C/man7/inotify.7:435
msgid ""
"Generates an B<IN_ATTRIB> event for I<myfile> and an B<IN_CREATE> event for "
"I<dir2>."
msgstr ""
"I<myfile> に対して B<IN_ATTRIB> イベントが生成され、 I<dir2> に対して "
"B<IN_CREATE> イベントが生成される。"

#. type: TP
#: build/C/man7/inotify.7:435
#, no-wrap
msgid "rename(\"dir1/myfile\", \"dir2/myfile\");"
msgstr "rename(\"dir1/myfile\", \"dir2/myfile\");"

#. type: Plain text
#: build/C/man7/inotify.7:456
msgid ""
"Generates an B<IN_MOVED_FROM> event for I<dir1>, an B<IN_MOVED_TO> event for "
"I<dir2>, and an B<IN_MOVE_SELF> event for I<myfile>.  The B<IN_MOVED_FROM> "
"and B<IN_MOVED_TO> events will have the same I<cookie> value."
msgstr ""
"I<dir1> に対してイベント B<IN_MOVED_FROM> が、 I<dir2> に対してイベント "
"B<IN_MOVED_TO> が、 I<myfile> に対してイベント B<IN_MOVE_SELF> が生成される。"
"この際 イベント B<IN_MOVED_FROM> と B<IN_MOVED_TO> は同じ I<cookie> 値を持"
"つ。"

#. type: Plain text
#: build/C/man7/inotify.7:470
msgid ""
"Suppose that I<dir1/xx> and I<dir2/yy> are (the only) links to the same "
"file, and an application is watching I<dir1>, I<dir2>, I<dir1/xx>, and "
"I<dir2/yy>.  Executing the following calls in the order given below will "
"generate the following events:"
msgstr ""
"I<dir1/xx> と I<dir2/yy> は同じファイルを参照するリンクで (他のリンクはないも"
"のとする)、 アプリケーションは I<dir1>, I<dir2>, I<dir1/xx>, I<dir2/yy> を監"
"視しているものとする。 以下に示す順序で下記の呼び出しを実行すると、以下のイベ"
"ントが生成される。"

#. type: TP
#: build/C/man7/inotify.7:471
#, no-wrap
msgid "unlink(\"dir2/yy\");"
msgstr "unlink(\"dir2/yy\");"

#. type: Plain text
#: build/C/man7/inotify.7:482
msgid ""
"Generates an B<IN_ATTRIB> event for I<xx> (because its link count changes)  "
"and an B<IN_DELETE> event for I<dir2>."
msgstr ""
"I<xx> に対して B<IN_ATTRIB> イベントが生成され (リンク数が変化したため)、 "
"I<dir2> に対して B<IN_DELETE> イベントが生成される。"

#. type: TP
#: build/C/man7/inotify.7:482
#, no-wrap
msgid "unlink(\"dir1/xx\");"
msgstr "unlink(\"dir1/xx\");"

#. type: Plain text
#: build/C/man7/inotify.7:495
msgid ""
"Generates B<IN_ATTRIB>, B<IN_DELETE_SELF>, and B<IN_IGNORED> events for "
"I<xx>, and an B<IN_DELETE> event for I<dir1>."
msgstr ""
"I<xx> に対してイベント B<IN_ATTRIB>, B<IN_DELETE_SELF>, B<IN_IGNORED> が生成"
"され、 I<dir1> に対して B<IN_DELETE> イベントが生成される。"

#. type: Plain text
#: build/C/man7/inotify.7:502
msgid ""
"Suppose an application is watching the directory I<dir> and (the empty) "
"directory I<dir/subdir>.  The following examples show some events that may "
"be generated."
msgstr ""
"アプリケーションがディレクトリ I<dir> と (空の) ディレクトリ I<dir/subdir> を"
"監視しているものとする。 以下に生成されるイベントの例を示す。"

#. type: TP
#: build/C/man7/inotify.7:503
#, no-wrap
msgid "mkdir(\"dir/new\", mode);"
msgstr "mkdir(\"dir/new\", mode);"

#. type: Plain text
#: build/C/man7/inotify.7:509
msgid "Generates an B<IN_CREATE | IN_ISDIR> event for I<dir>."
msgstr "I<dir> に対して B<IN_CREATE | IN_ISDIR> イベントが生成される。"

#. type: TP
#: build/C/man7/inotify.7:509
#, no-wrap
msgid "rmdir(\"dir/subdir\");"
msgstr "rmdir(\"dir/subdir\");"

#. type: Plain text
#: build/C/man7/inotify.7:521
msgid ""
"Generates B<IN_DELETE_SELF> and B<IN_IGNORED> events for I<subdir>, and an "
"B<IN_DELETE | IN_ISDIR> event for I<dir>."
msgstr ""
"I<subdir> に対してイベント B<IN_DELETE_SELF> と B<IN_IGNORED> が生成され、 "
"I<dir> に対して B<IN_DELETE | IN_ISDIR> イベントが生成される。"

#. type: SS
#: build/C/man7/inotify.7:522
#, no-wrap
msgid "/proc interfaces"
msgstr "/proc インターフェース"

#. type: Plain text
#: build/C/man7/inotify.7:525
msgid ""
"The following interfaces can be used to limit the amount of kernel memory "
"consumed by inotify:"
msgstr ""
"以下のインターフェースは、inotify で消費される カーネルメモリの総量を制限する"
"のに使用できる:"

#. type: TP
#: build/C/man7/inotify.7:525
#, no-wrap
msgid "I</proc/sys/fs/inotify/max_queued_events>"
msgstr "I</proc/sys/fs/inotify/max_queued_events>"

#. type: Plain text
#: build/C/man7/inotify.7:534
msgid ""
"The value in this file is used when an application calls B<inotify_init>(2)  "
"to set an upper limit on the number of events that can be queued to the "
"corresponding inotify instance.  Events in excess of this limit are dropped, "
"but an B<IN_Q_OVERFLOW> event is always generated."
msgstr ""
"このファイルの値は、アプリケーションが B<inotify_init>(2)  を呼び出すときに使"
"用され、対応する inotify インスタンスについて キューに入れられるイベントの数"
"の上限を設定する。 この制限を超えたイベントは破棄されるが、 B<IN_Q_OVERFLOW> "
"イベントが常に生成される。"

#. type: TP
#: build/C/man7/inotify.7:534
#, no-wrap
msgid "I</proc/sys/fs/inotify/max_user_instances>"
msgstr "I</proc/sys/fs/inotify/max_user_instances>"

#. type: Plain text
#: build/C/man7/inotify.7:538
msgid ""
"This specifies an upper limit on the number of inotify instances that can be "
"created per real user ID."
msgstr ""
"1 つの実ユーザ ID に対して生成できる inotify インスタンスの数の上限を指定す"
"る。"

#. type: TP
#: build/C/man7/inotify.7:538
#, no-wrap
msgid "I</proc/sys/fs/inotify/max_user_watches>"
msgstr "I</proc/sys/fs/inotify/max_user_watches>"

#. type: Plain text
#: build/C/man7/inotify.7:542
msgid ""
"This specifies an upper limit on the number of watches that can be created "
"per real user ID."
msgstr "作成可能な監視対象の数の実 UID 単位の上限を指定する。"

#. type: SH
#: build/C/man7/inotify.7:542 build/C/man2/inotify_add_watch.2:118
#: build/C/man2/inotify_init.2:94 build/C/man2/inotify_rm_watch.2:67
#: build/C/man2/fanotify_init.2:233 build/C/man2/fanotify_mark.2:299
#: build/C/man7/fanotify.7:446
#, no-wrap
msgid "VERSIONS"
msgstr "バージョン"

#. type: Plain text
#: build/C/man7/inotify.7:550
msgid ""
"Inotify was merged into the 2.6.13 Linux kernel.  The required library "
"interfaces were added to glibc in version 2.4.  (B<IN_DONT_FOLLOW>, "
"B<IN_MASK_ADD>, and B<IN_ONLYDIR> were added in glibc version 2.5.)"
msgstr ""
"inotify は 2.6.13 の Linux カーネルに組込まれた。 これに必要なライブラリのイ"
"ンターフェースは、 glibc のバージョン 2.4 に追加された (B<IN_DONT_FOLLOW>, "
"B<IN_MASK_ADD>, B<IN_ONLYDIR> は glibc バージョン 2.5 で追加された)。"

#. type: SH
#: build/C/man7/inotify.7:550 build/C/man2/inotify_add_watch.2:120
#: build/C/man2/inotify_init.2:101 build/C/man2/inotify_rm_watch.2:69
#: build/C/man2/fanotify_init.2:237 build/C/man2/fanotify_mark.2:303
#: build/C/man7/fanotify.7:450
#, no-wrap
msgid "CONFORMING TO"
msgstr "準拠"

#. type: Plain text
#: build/C/man7/inotify.7:552
msgid "The inotify API is Linux-specific."
msgstr "inotify API は Linux 独自のものである。"

#. type: SH
#: build/C/man7/inotify.7:552 build/C/man7/fanotify.7:452
#, no-wrap
msgid "NOTES"
msgstr "注意"

#. type: Plain text
#: build/C/man7/inotify.7:559
msgid ""
"Inotify file descriptors can be monitored using B<select>(2), B<poll>(2), "
"and B<epoll>(7).  When an event is available, the file descriptor indicates "
"as readable."
msgstr ""
"inotify ファイルディスクリプタは B<select>(2), B<poll>(2), B<epoll>(7)  を"
"使って監視できる。 イベントがある場合、ファイルディスクリプタは読み込み可能と"
"通知する。"

#. type: Plain text
#: build/C/man7/inotify.7:588
msgid ""
"Since Linux 2.6.25, signal-driven I/O notification is available for inotify "
"file descriptors; see the discussion of B<F_SETFL> (for setting the "
"B<O_ASYNC> flag), B<F_SETOWN>, and B<F_SETSIG> in B<fcntl>(2).  The "
"I<siginfo_t> structure (described in B<sigaction>(2))  that is passed to the "
"signal handler has the following fields set: I<si_fd> is set to the inotify "
"file descriptor number; I<si_signo> is set to the signal number; I<si_code> "
"is set to B<POLL_IN>; and B<POLLIN> is set in I<si_band>."
msgstr ""
"Linux 2.6.25 以降では、シグナル駆動 (signal-driven) I/O の通知が inotify ファ"
"イルディスクリプタについて利用可能である。 B<fcntl>(2)  に書かれている "
"(B<O_ASYNC> フラグを設定するための)  B<F_SETFL>, B<F_SETOWN>, B<F_SETSIG> の"
"議論を参照のこと。 シグナルハンドラに渡される I<siginfo_t> 構造体は、以下の"
"フィールドが設定される (I<siginfo_t> は B<sigaction>(2)  で説明されている)。 "
"I<si_fd> には inotify ファイルディスクリプタ番号が、 I<si_signo> にはシグナル"
"番号が、 I<si_code> には B<POLL_IN> が、 I<si_band> には B<POLLIN> が設定され"
"る。"

#. type: Plain text
#: build/C/man7/inotify.7:601
msgid ""
"If successive output inotify events produced on the inotify file descriptor "
"are identical (same I<wd>, I<mask>, I<cookie>, and I<name>), then they are "
"coalesced into a single event if the older event has not yet been read (but "
"see BUGS).  This reduces the amount of kernel memory required for the event "
"queue, but also means that an application can't use inotify to reliably "
"count file events."
msgstr ""
"inotify ファイルディスクリプタに対して 連続して生成される出力 inotify イベン"
"トが同一の場合 (I<wd>, I<mask>, I<cookie>, I<name> が等しい場合)、 前のイベン"
"トがまだ読み込まれていなければ、 連続するイベントが 1 つのイベントにまとめら"
"れる (ただし「バグ」の節も参照のこと)。 これによりイベントキューに必要なカー"
"ネルメモリ量が減るが、 これはまたアプリケーションがファイルイベント数を信頼性"
"を持って数えるのに inotify を使用できないということでもある。"

#. type: Plain text
#: build/C/man7/inotify.7:607
msgid ""
"The events returned by reading from an inotify file descriptor form an "
"ordered queue.  Thus, for example, it is guaranteed that when renaming from "
"one directory to another, events will be produced in the correct order on "
"the inotify file descriptor."
msgstr ""
"inotify ファイルディスクリプタの読み込みで返されるイベントは、 順序付けられた"
"キューになる。 従って、たとえば、あるディレクトリの名前を別の名前に変更した場"
"合、 inotify ファイルディスクリプタについての正しい順番で イベントが生成され"
"ることが保証される。"

#. type: Plain text
#: build/C/man7/inotify.7:613
msgid ""
"The B<FIONREAD> B<ioctl>(2)  returns the number of bytes available to read "
"from an inotify file descriptor."
msgstr ""
"B<FIONREAD> B<ioctl>(2)  は inotify ファイルディスクリプタから何バイト読み込"
"めるかを返す。"

#. type: SS
#: build/C/man7/inotify.7:613 build/C/man7/fanotify.7:459
#, no-wrap
msgid "Limitations and caveats"
msgstr "制限と警告"

#. type: Plain text
#: build/C/man7/inotify.7:620
msgid ""
"The inotify API provides no information about the user or process that "
"triggered the inotify event.  In particular, there is no easy way for a "
"process that is monitoring events via inotify to distinguish events that it "
"triggers itself from those that are triggered by other processes."
msgstr ""
"inotify API では、inotify イベントが発生するきっかけとなったユーザやプロセス"
"に関する情報は提供されない。とりわけ、inotify 経由でイベントを監視しているプ"
"ロセスが、自分自身がきっかけとなったイベントと他のプロセスがきっかけとなった"
"イベントを区別する簡単な手段はない。"

#. type: Plain text
#: build/C/man7/inotify.7:633
msgid ""
"Inotify reports only events that a user-space program triggers through the "
"filesystem API.  As a result, it does not catch remote events that occur on "
"network filesystems.  (Applications must fall back to polling the filesystem "
"to catch such events.)  Furthermore, various pseudo-filesystems such as I</"
"proc>, I</sys>, and I</dev/pts> are not monitorable with inotify."
msgstr ""
"inotify は、ファイルシステム API 経由でユーザー空間プログラムがきっかけとなっ"
"たイベントだけを報告する。 結果として、 inotify はネットワークファイルシステ"
"ムで発生したリモートのイベントを捉えることはできない (このようなイベントを捉"
"えるにはアプリケーションはファイルシステムをポーリングする必要がある)。 さら"
"に、 I</proc>, I</sys>, I</dev/pts> といったいくつかの疑似ファイルシステムは "
"inotify で監視することができない。"

#. type: Plain text
#: build/C/man7/inotify.7:640
msgid ""
"The inotify API does not report file accesses and modifications that may "
"occur because of B<mmap>(2), B<msync>(2), and B<munmap>(2)."
msgstr "inotify API は B<mmap>(2), B<msync>(2), B<munmap>(2) により起こったファイルのアクセスと変更を報告しない。"

#. type: Plain text
#: build/C/man7/inotify.7:644
msgid ""
"The inotify API identifies affected files by filename.  However, by the time "
"an application processes an inotify event, the filename may already have "
"been deleted or renamed."
msgstr ""
"inotify API では影響が受けるファイルをファイル名で特定する。\n"
"しかしながら、アプリケーションが inotify イベントを処理する時点では、\n"
"そのファイル名がすでに削除されたり変更されたりしている可能性がある。"

#. type: Plain text
#: build/C/man7/inotify.7:649
msgid ""
"The inotify API identifies events via watch descriptors.  It is the "
"application's responsibility to cache a mapping (if one is needed) between "
"watch descriptors and pathnames.  Be aware that directory renamings may "
"affect multiple cached pathnames."
msgstr ""
"inotify API では監視対象ディスクリプタを通してイベントが区別される。 (必要で"
"あれば) 監視対象ディスクリプタとパス名のマッピングをキャッシュしておくのはア"
"プリケーションの役目である。 ディレクトリの名前変更の場合、キャッシュしている"
"複数のパス名に影響がある点に注意すること。"

#. type: Plain text
#: build/C/man7/inotify.7:654
msgid ""
"Inotify monitoring of directories is not recursive: to monitor "
"subdirectories under a directory, additional watches must be created.  This "
"can take a significant amount time for large directory trees."
msgstr ""
"inotify によるディレクトリの監視は再帰的に行われない: あるディレクトリ以下"
"の\n"
"サブディレクトリを監視する場合、 監視対象を追加で作成しなければならない。\n"
"大きなディレクトリツリーの場合には、この作業にかなり時間がかかることがある。"

#. type: Plain text
#: build/C/man7/inotify.7:663
msgid ""
"If monitoring an entire directory subtree, and a new subdirectory is created "
"in that tree or an existing directory is renamed into that tree, be aware "
"that by the time you create a watch for the new subdirectory, new files (and "
"subdirectories) may already exist inside the subdirectory.  Therefore, you "
"may want to scan the contents of the subdirectory immediately after adding "
"the watch (and, if desired, recursively add watches for any subdirectories "
"that it contains)."
msgstr ""
"ディレクトリツリー全体を監視していて、 そのツリー内に新しいサブディレクトリが"
"作成されるか、 既存のディレクトリが名前が変更されそのツリー内に移動した場"
"合、 新しいサブディレクトリに対する watch を作成するまでに、 新しいファイル "
"(やサブディレクトリ) がそのサブディレクトリ内にすでに作成されている場合がある"
"点に注意すること。 したがって、watch を追加した直後にサブディレクトリの内容を"
"スキャンしたいと思う場合もあるだろう (必要ならそのサブディレクトリ内のサブ"
"ディレクトリに対する watch も再帰的に追加することもあるだろう)。"

#. type: Plain text
#: build/C/man7/inotify.7:675
msgid ""
"Note that the event queue can overflow.  In this case, events are lost.  "
"Robust applications should handle the possibility of lost events "
"gracefully.  For example, it may be necessary to rebuild part or all of the "
"application cache.  (One simple, but possibly expensive, approach is to "
"close the inotify file descriptor, empty the cache, create a new inotify "
"file descriptor, and then re-create watches and cache entries for the "
"objects to be monitored.)"
msgstr ""
"イベントキューはオーバーフローする場合があることに注意すること。 この場合、イ"
"ベントは失なわれる。 ロバスト性が求められるアプリケーションでは、 イベントが"
"失なわれる可能性も含めて適切に処理を行うべきである。 例えば、アプリケーション"
"内のキャッシュの一部分または全てを再構築する必要があるかもしれない。 (単純だ"
"が、おそらくコストがかかる方法は、 inotify ファイルディスクリプタをクローズ"
"し、 キャッシュを空にし、 新しい inotify ファイルディスクリプタを作成し、 監"
"視しているオブジェクトの監視対象ディスクリプタとキャッシュエントリーの再作成"
"を行う方法である。)"

#. type: SS
#: build/C/man7/inotify.7:675
#, no-wrap
msgid "Dealing with rename() events"
msgstr "rename() イベントの取り扱い"

#. type: Plain text
#: build/C/man7/inotify.7:684
msgid ""
"As noted above, the B<IN_MOVED_FROM> and B<IN_MOVED_TO> event pair that is "
"generated by B<rename>(2)  can be matched up via their shared cookie value.  "
"However, the task of matching has some challenges."
msgstr ""
"上述の通り、 B<rename>(2) により生成される B<IN_MOVED_FROM> と "
"B<IN_MOVED_TO> イベントの組は、共有される cookie 値によって対応を取ることがで"
"きる。 しかし、対応を取る場合にはいくつか難しい点がある。"

#. type: Plain text
#: build/C/man7/inotify.7:695
msgid ""
"These two events are usually consecutive in the event stream available when "
"reading from the inotify file descriptor.  However, this is not guaranteed.  "
"If multiple processes are triggering events for monitored objects, then (on "
"rare occasions) an arbitrary number of other events may appear between the "
"B<IN_MOVED_FROM> and B<IN_MOVED_TO> events."
msgstr ""
"これらの 2 つのイベントは、 inotify ファイルディスクリプタから読み出しを行っ"
"た場合に、通常はイベントストリーム内で連続している。 しかしながら、連続してい"
"ることは保証されていない。 複数のプロセスが監視対象オブジェクトでイベントを発"
"生させた場合、 (めったに起こらないことだが) イベント B<IN_MOVED_FROM> と "
"B<IN_MOVED_TO> の間に任意の数の他のイベントがはさまる可能性がある。"

#. type: Plain text
#: build/C/man7/inotify.7:720
msgid ""
"Matching up the B<IN_MOVED_FROM> and B<IN_MOVED_TO> event pair generated by "
"B<rename>(2)  is thus inherently racy.  (Don't forget that if an object is "
"renamed outside of a monitored directory, there may not even be an "
"B<IN_MOVED_TO> event.)  Heuristic approaches (e.g., assume the events are "
"always consecutive)  can be used to ensure a match in most cases, but will "
"inevitably miss some cases, causing the application to perceive the "
"B<IN_MOVED_FROM> and B<IN_MOVED_TO> events as being unrelated.  If watch "
"descriptors are destroyed and re-created as a result, then those watch "
"descriptors will be inconsistent with the watch descriptors in any pending "
"events.  (Re-creating the inotify file descriptor and rebuilding the cache "
"may be useful to deal with this scenario.)"
msgstr ""
"したがって、 B<rename>(2) により生成された B<IN_MOVED_FROM> と "
"B<IN_MOVED_TO> のイベントの組の対応を取るのは本質的に難しいことである (監視対"
"象のディレクトリの外へオブジェクトの rename が行われた場合には "
"B<IN_MOVED_TO> イベントは存在しさえしないことを忘れてはならない)。 (イベント"
"は常に連続しているとの仮定を置くといった) 発見的な方法を使うと、ほとんどの場"
"合でイベントの組をうまく見つけることができるが、 いくつかの場合に見逃すことが"
"避けられず、 アプリケーションが B<IN_MOVED_FROM> と B<IN_MOVED_TO> イベントが"
"無関係だとみなしてしまう可能性がある。 結果的に、監視対象ディスクリプタが破棄"
"され再作成された場合、これらの監視対象ディスクリプタは、処理待ちイベントの監"
"視対象ディスクリプタと一貫性のないものになってしまう (inotify ファイルディス"
"クリプタの再作成とキャッシュの再構成はこの状況に対処するのに有用な方法なのだ"
"が)。"

#. type: Plain text
#: build/C/man7/inotify.7:730
msgid ""
"Applications should also allow for the possibility that the B<IN_MOVED_FROM> "
"event was the last event that could fit in the buffer returned by the "
"current call to B<read>(2), and the accompanying B<IN_MOVED_TO> event might "
"be fetched only on the next B<read>(2)."
msgstr ""
"また、アプリケーションは、 B<IN_MOVED_FROM> イベントが今行った B<read>(2) の"
"呼び出しで返されたバッファのちょうど一番最後のイベントで、 B<IN_MOVED_TO> イ"
"ベントは次の B<read>(2) を行わないと取得できない可能性も考慮に入れる必要があ"
"る。"

#. type: SH
#: build/C/man7/inotify.7:730 build/C/man2/fanotify_init.2:239
#: build/C/man2/fanotify_mark.2:305 build/C/man7/fanotify.7:487
#, no-wrap
msgid "BUGS"
msgstr "バグ"

#.  FIXME kernel commit 611da04f7a31b2208e838be55a42c7a1310ae321
#.  implies that unmount events were buggy 2.6.11 to 2.6.36
#. type: Plain text
#: build/C/man7/inotify.7:738
msgid "In kernels before 2.6.16, the B<IN_ONESHOT> I<mask> flag does not work."
msgstr "2.6.16 以前のカーネルでは B<IN_ONESHOT> I<mask> フラグが働かない。"

#. type: Plain text
#: build/C/man7/inotify.7:748
msgid ""
"As originally designed and implemented, the B<IN_ONESHOT> flag did not cause "
"an B<IN_IGNORED> event to be generated when the watch was dropped after one "
"event.  However, as an unintended effect of other changes, since Linux "
"2.6.36, an B<IN_IGNORED> event is generated in this case."
msgstr ""
"元々は設計/実装時の意図通り、 イベントが一つ発生し watch が削除された際に "
"B<IN_ONESHOT> フラグでは B<IN_IGNORED> イベントが発生しなかった。 しかし、 別"
"の変更での意図していなかった影響により、 Linux 2.6.36 以降では、 この場合に "
"B<IN_IGNORED> イベントが生成される。"

#.  commit 1c17d18e3775485bf1e0ce79575eb637a94494a2
#. type: Plain text
#: build/C/man7/inotify.7:757
msgid ""
"Before kernel 2.6.25, the kernel code that was intended to coalesce "
"successive identical events (i.e., the two most recent events could "
"potentially be coalesced if the older had not yet been read)  instead "
"checked if the most recent event could be coalesced with the I<oldest> "
"unread event."
msgstr ""
"カーネル 2.6.25 より前では、 連続する同一のイベントを一つにまとめることを意図"
"したコード (古い方のイベントがまだ読み込まれていない場合に、 最新の 2 つのイ"
"ベントを一つにまとめられる可能性がある) が、 最新のイベントが「最も古い」読み"
"込まれていないイベントとまとめられるか をチェックするようになっていた。"

#. type: SH
#: build/C/man7/inotify.7:757 build/C/man7/fanotify.7:509
#, no-wrap
msgid "EXAMPLE"
msgstr "例"

#. type: Plain text
#: build/C/man7/inotify.7:765
msgid ""
"The following program demonstrates the usage of the inotify API.  It marks "
"the directories passed as a command-line arguments and waits for events of "
"type B<IN_OPEN>, B<IN_CLOSE_NOWRITE> and B<IN_CLOSE_WRITE>."
msgstr "以下のプログラムは inotify API の使用例を示したものである。 コマンドライン引き数で渡されたディレクトリに印を付け、 タイプが B<IN_OPEN>, B<IN_CLOSE_NOWRITE> B<IN_CLOSE_WRITE> のイベントを待つ。"

#. type: Plain text
#: build/C/man7/inotify.7:780
msgid ""
"The following output was recorded while editing the file I</home/user/temp/"
"foo> and listing directory I</tmp>.  Before the file and the directory were "
"opened, B<IN_OPEN> events occurred.  After the file was closed, an "
"B<IN_CLOSE_WRITE> event occurred.  After the directory was closed, an "
"B<IN_CLOSE_NOWRITE> event occurred.  Execution of the program ended when the "
"user pressed the ENTER key."
msgstr "以下は、 ファイル I</home/user/temp/foo> を編集し、 ディレクトリ I</tmp> の一覧表示を行った場合の出力である。 対象のファイルとディレクトリがオープンされる前に、イベント B<IN_OPEN> が発生している。 対象ファイルがクローズされた後にイベント B<IN_CLOSE_WRITE> が発生している。 対象ディレクトリがクローズされた後にイベント B<IN_CLOSE_NOWRITE> が発生している。 ユーザーが ENTER キーを押すると、プログラムの実行は終了する。"

#. type: SS
#: build/C/man7/inotify.7:780 build/C/man7/fanotify.7:529
#, no-wrap
msgid "Example output"
msgstr "出力例"

#. type: Plain text
#: build/C/man7/inotify.7:790
#, no-wrap
msgid ""
"$ B<./a.out /tmp /home/user/temp>\n"
"Press enter key to terminate.\n"
"Listening for events.\n"
"IN_OPEN: /home/user/temp/foo [file]\n"
"IN_CLOSE_WRITE: /home/user/temp/foo [file]\n"
"IN_OPEN: /tmp/ [directory]\n"
"IN_CLOSE_NOWRITE: /tmp/ [directory]\n"
msgstr ""
"$ B<./a.out /tmp /home/user/temp>\n"
"Press enter key to terminate.\n"
"Listening for events.\n"
"IN_OPEN: /home/user/temp/foo [file]\n"
"IN_CLOSE_WRITE: /home/user/temp/foo [file]\n"
"IN_OPEN: /tmp/ [directory]\n"
"IN_CLOSE_NOWRITE: /tmp/ [directory]\n"

#. type: Plain text
#: build/C/man7/inotify.7:792 build/C/man7/fanotify.7:539
#, no-wrap
msgid "Listening for events stopped.\n"
msgstr "Listening for events stopped.\n"

#. type: SS
#: build/C/man7/inotify.7:794 build/C/man7/fanotify.7:541
#, no-wrap
msgid "Program source"
msgstr "プログラムソース"

#. type: Plain text
#: build/C/man7/inotify.7:802
#, no-wrap
msgid ""
"#include E<lt>errno.hE<gt>\n"
"#include E<lt>poll.hE<gt>\n"
"#include E<lt>stdio.hE<gt>\n"
"#include E<lt>stdlib.hE<gt>\n"
"#include E<lt>sys/inotify.hE<gt>\n"
"#include E<lt>unistd.hE<gt>\n"
msgstr ""
"#include E<lt>errno.hE<gt>\n"
"#include E<lt>poll.hE<gt>\n"
"#include E<lt>stdio.hE<gt>\n"
"#include E<lt>stdlib.hE<gt>\n"
"#include E<lt>sys/inotify.hE<gt>\n"
"#include E<lt>unistd.hE<gt>\n"

#. type: Plain text
#: build/C/man7/inotify.7:808
#, no-wrap
msgid ""
"/* Read all available inotify events from the file descriptor 'fd'.\n"
"   wd is the table of watch descriptors for the directories in argv.\n"
"   argc is the length of wd and argv.\n"
"   argv is the list of watched directories.\n"
"   Entry 0 of wd and argv is unused. */\n"
msgstr ""
"/* Read all available inotify events from the file descriptor 'fd'.\n"
"   wd is the table of watch descriptors for the directories in argv.\n"
"   argc is the length of wd and argv.\n"
"   argv is the list of watched directories.\n"
"   Entry 0 of wd and argv is unused. */\n"

#. type: Plain text
#: build/C/man7/inotify.7:817
#, no-wrap
msgid ""
"static void\n"
"handle_events(int fd, int *wd, int argc, char* argv[])\n"
"{\n"
"    /* Some systems cannot read integer variables if they are not\n"
"       properly aligned. On other systems, incorrect alignment may\n"
"       decrease performance. Hence, the buffer used for reading from\n"
"       the inotify file descriptor should have the same alignment as\n"
"       struct inotify_event. */\n"
msgstr ""
"static void\n"
"handle_events(int fd, int *wd, int argc, char* argv[])\n"
"{\n"
"    /* Some systems cannot read integer variables if they are not\n"
"       properly aligned. On other systems, incorrect alignment may\n"
"       decrease performance. Hence, the buffer used for reading from\n"
"       the inotify file descriptor should have the same alignment as\n"
"       struct inotify_event. */\n"

#. type: Plain text
#: build/C/man7/inotify.7:824
#, no-wrap
msgid ""
"    char buf[4096]\n"
"        __attribute__ ((aligned(__alignof__(struct inotify_event))));\n"
"    const struct inotify_event *event;\n"
"    int i;\n"
"    ssize_t len;\n"
"    char *ptr;\n"
msgstr ""
"    char buf[4096]\n"
"        __attribute__ ((aligned(__alignof__(struct inotify_event))));\n"
"    const struct inotify_event *event;\n"
"    int i;\n"
"    ssize_t len;\n"
"    char *ptr;\n"

#. type: Plain text
#: build/C/man7/inotify.7:826
#, no-wrap
msgid "    /* Loop while events can be read from inotify file descriptor. */\n"
msgstr "    /* Loop while events can be read from inotify file descriptor. */\n"

#. type: Plain text
#: build/C/man7/inotify.7:828
#, no-wrap
msgid "    for (;;) {\n"
msgstr "    for (;;) {\n"

#. type: Plain text
#: build/C/man7/inotify.7:830
#, no-wrap
msgid "        /* Read some events. */\n"
msgstr "        /* Read some events. */\n"

#. type: Plain text
#: build/C/man7/inotify.7:836
#, no-wrap
msgid ""
"        len = read(fd, buf, sizeof buf);\n"
"        if (len == -1 && errno != EAGAIN) {\n"
"            perror(\"read\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"
msgstr ""
"        len = read(fd, buf, sizeof buf);\n"
"        if (len == -1 && errno != EAGAIN) {\n"
"            perror(\"read\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"

#. type: Plain text
#: build/C/man7/inotify.7:840
#, no-wrap
msgid ""
"        /* If the nonblocking read() found no events to read, then\n"
"           it returns -1 with errno set to EAGAIN. In that case,\n"
"           we exit the loop. */\n"
msgstr ""
"        /* If the nonblocking read() found no events to read, then\n"
"           it returns -1 with errno set to EAGAIN. In that case,\n"
"           we exit the loop. */\n"

#. type: Plain text
#: build/C/man7/inotify.7:843 build/C/man7/fanotify.7:582
#, no-wrap
msgid ""
"        if (len E<lt>= 0)\n"
"            break;\n"
msgstr ""
"        if (len E<lt>= 0)\n"
"            break;\n"

#. type: Plain text
#: build/C/man7/inotify.7:845 build/C/man7/fanotify.7:588
#, no-wrap
msgid "        /* Loop over all events in the buffer */\n"
msgstr "        /* Loop over all events in the buffer */\n"

#. type: Plain text
#: build/C/man7/inotify.7:848
#, no-wrap
msgid ""
"        for (ptr = buf; ptr E<lt> buf + len;\n"
"                ptr += sizeof(struct inotify_event) + event-E<gt>len) {\n"
msgstr ""
"        for (ptr = buf; ptr E<lt> buf + len;\n"
"                ptr += sizeof(struct inotify_event) + event-E<gt>len) {\n"

#. type: Plain text
#: build/C/man7/inotify.7:850
#, no-wrap
msgid "            event = (const struct inotify_event *) ptr;\n"
msgstr "            event = (const struct inotify_event *) ptr;\n"

#. type: Plain text
#: build/C/man7/inotify.7:852
#, no-wrap
msgid "            /* Print event type */\n"
msgstr "            /* Print event type */\n"

#. type: Plain text
#: build/C/man7/inotify.7:859
#, no-wrap
msgid ""
"            if (event-E<gt>mask & IN_OPEN)\n"
"                printf(\"IN_OPEN: \");\n"
"            if (event-E<gt>mask & IN_CLOSE_NOWRITE)\n"
"                printf(\"IN_CLOSE_NOWRITE: \");\n"
"            if (event-E<gt>mask & IN_CLOSE_WRITE)\n"
"                printf(\"IN_CLOSE_WRITE: \");\n"
msgstr ""
"            if (event-E<gt>mask & IN_OPEN)\n"
"                printf(\"IN_OPEN: \");\n"
"            if (event-E<gt>mask & IN_CLOSE_NOWRITE)\n"
"                printf(\"IN_CLOSE_NOWRITE: \");\n"
"            if (event-E<gt>mask & IN_CLOSE_WRITE)\n"
"                printf(\"IN_CLOSE_WRITE: \");\n"

#. type: Plain text
#: build/C/man7/inotify.7:861
#, no-wrap
msgid "            /* Print the name of the watched directory */\n"
msgstr "            /* Print the name of the watched directory */\n"

#. type: Plain text
#: build/C/man7/inotify.7:868
#, no-wrap
msgid ""
"            for (i = 1; i E<lt> argc; ++i) {\n"
"                if (wd[i] == event-E<gt>wd) {\n"
"                    printf(\"%s/\", argv[i]);\n"
"                    break;\n"
"                }\n"
"            }\n"
msgstr ""
"            for (i = 1; i E<lt> argc; ++i) {\n"
"                if (wd[i] == event-E<gt>wd) {\n"
"                    printf(\"%s/\", argv[i]);\n"
"                    break;\n"
"                }\n"
"            }\n"

#. type: Plain text
#: build/C/man7/inotify.7:870
#, no-wrap
msgid "            /* Print the name of the file */\n"
msgstr "            /* Print the name of the file */\n"

#. type: Plain text
#: build/C/man7/inotify.7:873
#, no-wrap
msgid ""
"            if (event-E<gt>len)\n"
"                printf(\"%s\", event-E<gt>name);\n"
msgstr ""
"            if (event-E<gt>len)\n"
"                printf(\"%s\", event-E<gt>name);\n"

#. type: Plain text
#: build/C/man7/inotify.7:875
#, no-wrap
msgid "            /* Print type of filesystem object */\n"
msgstr "            /* Print type of filesystem object */\n"

#. type: Plain text
#: build/C/man7/inotify.7:883
#, no-wrap
msgid ""
"            if (event-E<gt>mask & IN_ISDIR)\n"
"                printf(\" [directory]\\en\");\n"
"            else\n"
"                printf(\" [file]\\en\");\n"
"        }\n"
"    }\n"
"}\n"
msgstr ""
"            if (event-E<gt>mask & IN_ISDIR)\n"
"                printf(\" [directory]\\en\");\n"
"            else\n"
"                printf(\" [file]\\en\");\n"
"        }\n"
"    }\n"
"}\n"

#. type: Plain text
#: build/C/man7/inotify.7:892
#, no-wrap
msgid ""
"int\n"
"main(int argc, char* argv[])\n"
"{\n"
"    char buf;\n"
"    int fd, i, poll_num;\n"
"    int *wd;\n"
"    nfds_t nfds;\n"
"    struct pollfd fds[2];\n"
msgstr ""
"int\n"
"main(int argc, char* argv[])\n"
"{\n"
"    char buf;\n"
"    int fd, i, poll_num;\n"
"    int *wd;\n"
"    nfds_t nfds;\n"
"    struct pollfd fds[2];\n"

#. type: Plain text
#: build/C/man7/inotify.7:897
#, no-wrap
msgid ""
"    if (argc E<lt> 2) {\n"
"        printf(\"Usage: %s PATH [PATH ...]\\en\", argv[0]);\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"
msgstr ""
"    if (argc E<lt> 2) {\n"
"        printf(\"Usage: %s PATH [PATH ...]\\en\", argv[0]);\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"

#. type: Plain text
#: build/C/man7/inotify.7:899
#, no-wrap
msgid "    printf(\"Press ENTER key to terminate.\\en\");\n"
msgstr "    printf(\"Press ENTER key to terminate.\\en\");\n"

#. type: Plain text
#: build/C/man7/inotify.7:901
#, no-wrap
msgid "    /* Create the file descriptor for accessing the inotify API */\n"
msgstr "    /* Create the file descriptor for accessing the inotify API */\n"

#. type: Plain text
#: build/C/man7/inotify.7:907
#, no-wrap
msgid ""
"    fd = inotify_init1(IN_NONBLOCK);\n"
"    if (fd == -1) {\n"
"        perror(\"inotify_init1\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"
msgstr ""
"    fd = inotify_init1(IN_NONBLOCK);\n"
"    if (fd == -1) {\n"
"        perror(\"inotify_init1\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"

#. type: Plain text
#: build/C/man7/inotify.7:909
#, no-wrap
msgid "    /* Allocate memory for watch descriptors */\n"
msgstr "    /* Allocate memory for watch descriptors */\n"

#. type: Plain text
#: build/C/man7/inotify.7:915
#, no-wrap
msgid ""
"    wd = calloc(argc, sizeof(int));\n"
"    if (wd == NULL) {\n"
"        perror(\"calloc\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"
msgstr ""
"    wd = calloc(argc, sizeof(int));\n"
"    if (wd == NULL) {\n"
"        perror(\"calloc\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"

#. type: Plain text
#: build/C/man7/inotify.7:919
#, no-wrap
msgid ""
"    /* Mark directories for events\n"
"       - file was opened\n"
"       - file was closed */\n"
msgstr ""
"    /* Mark directories for events\n"
"       - file was opened\n"
"       - file was closed */\n"

#. type: Plain text
#: build/C/man7/inotify.7:929
#, no-wrap
msgid ""
"    for (i = 1; i E<lt> argc; i++) {\n"
"        wd[i] = inotify_add_watch(fd, argv[i],\n"
"                                  IN_OPEN | IN_CLOSE);\n"
"        if (wd[i] == -1) {\n"
"            fprintf(stderr, \"Cannot watch '%s'\\en\", argv[i]);\n"
"            perror(\"inotify_add_watch\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"
"    }\n"
msgstr ""
"    for (i = 1; i E<lt> argc; i++) {\n"
"        wd[i] = inotify_add_watch(fd, argv[i],\n"
"                                  IN_OPEN | IN_CLOSE);\n"
"        if (wd[i] == -1) {\n"
"            fprintf(stderr, \"Cannot watch '%s'\\en\", argv[i]);\n"
"            perror(\"inotify_add_watch\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"
"    }\n"

#. type: Plain text
#: build/C/man7/inotify.7:931 build/C/man7/fanotify.7:688
#, no-wrap
msgid "    /* Prepare for polling */\n"
msgstr "    /* Prepare for polling */\n"

#. type: Plain text
#: build/C/man7/inotify.7:933 build/C/man7/fanotify.7:690
#, no-wrap
msgid "    nfds = 2;\n"
msgstr "    nfds = 2;\n"

#. type: Plain text
#: build/C/man7/inotify.7:935 build/C/man7/fanotify.7:692
#, no-wrap
msgid "    /* Console input */\n"
msgstr "    /* Console input */\n"

#. type: Plain text
#: build/C/man7/inotify.7:938 build/C/man7/fanotify.7:695
#, no-wrap
msgid ""
"    fds[0].fd = STDIN_FILENO;\n"
"    fds[0].events = POLLIN;\n"
msgstr ""
"    fds[0].fd = STDIN_FILENO;\n"
"    fds[0].events = POLLIN;\n"

#. type: Plain text
#: build/C/man7/inotify.7:940
#, no-wrap
msgid "    /* Inotify input */\n"
msgstr "    /* Inotify input */\n"

#. type: Plain text
#: build/C/man7/inotify.7:943 build/C/man7/fanotify.7:700
#, no-wrap
msgid ""
"    fds[1].fd = fd;\n"
"    fds[1].events = POLLIN;\n"
msgstr ""
"    fds[1].fd = fd;\n"
"    fds[1].events = POLLIN;\n"

#. type: Plain text
#: build/C/man7/inotify.7:945
#, no-wrap
msgid "    /* Wait for events and/or terminal input */\n"
msgstr "    /* Wait for events and/or terminal input */\n"

#. type: Plain text
#: build/C/man7/inotify.7:955
#, no-wrap
msgid ""
"    printf(\"Listening for events.\\en\");\n"
"    while (1) {\n"
"        poll_num = poll(fds, nfds, -1);\n"
"        if (poll_num == -1) {\n"
"            if (errno == EINTR)\n"
"                continue;\n"
"            perror(\"poll\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"
msgstr ""
"    printf(\"Listening for events.\\en\");\n"
"    while (1) {\n"
"        poll_num = poll(fds, nfds, -1);\n"
"        if (poll_num == -1) {\n"
"            if (errno == EINTR)\n"
"                continue;\n"
"            perror(\"poll\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"

#. type: Plain text
#: build/C/man7/inotify.7:957
#, no-wrap
msgid "        if (poll_num E<gt> 0) {\n"
msgstr "        if (poll_num E<gt> 0) {\n"

#. type: Plain text
#: build/C/man7/inotify.7:959
#, no-wrap
msgid "            if (fds[0].revents & POLLIN) {\n"
msgstr "            if (fds[0].revents & POLLIN) {\n"

#. type: Plain text
#: build/C/man7/inotify.7:961
#, no-wrap
msgid "                /* Console input is available. Empty stdin and quit */\n"
msgstr "                /* Console input is available. Empty stdin and quit */\n"

#. type: Plain text
#: build/C/man7/inotify.7:966 build/C/man7/fanotify.7:724
#, no-wrap
msgid ""
"                while (read(STDIN_FILENO, &buf, 1) E<gt> 0 && buf != '\\en')\n"
"                    continue;\n"
"                break;\n"
"            }\n"
msgstr ""
"                while (read(STDIN_FILENO, &buf, 1) E<gt> 0 && buf != '\\en')\n"
"                    continue;\n"
"                break;\n"
"            }\n"

#. type: Plain text
#: build/C/man7/inotify.7:968 build/C/man7/fanotify.7:726
#, no-wrap
msgid "            if (fds[1].revents & POLLIN) {\n"
msgstr "            if (fds[1].revents & POLLIN) {\n"

#. type: Plain text
#: build/C/man7/inotify.7:970
#, no-wrap
msgid "                /* Inotify events are available */\n"
msgstr "                /* Inotify events are available */\n"

#. type: Plain text
#: build/C/man7/inotify.7:975
#, no-wrap
msgid ""
"                handle_events(fd, wd, argc, argv);\n"
"            }\n"
"        }\n"
"    }\n"
msgstr ""
"                handle_events(fd, wd, argc, argv);\n"
"            }\n"
"        }\n"
"    }\n"

#. type: Plain text
#: build/C/man7/inotify.7:977
#, no-wrap
msgid "    printf(\"Listening for events stopped.\\en\");\n"
msgstr "    printf(\"Listening for events stopped.\\en\");\n"

#. type: Plain text
#: build/C/man7/inotify.7:979
#, no-wrap
msgid "    /* Close inotify file descriptor */\n"
msgstr "    /* Close inotify file descriptor */\n"

#. type: Plain text
#: build/C/man7/inotify.7:981
#, no-wrap
msgid "    close(fd);\n"
msgstr "    close(fd);\n"

#. type: Plain text
#: build/C/man7/inotify.7:985
#, no-wrap
msgid ""
"    free(wd);\n"
"    exit(EXIT_SUCCESS);\n"
"}\n"
msgstr ""
"    free(wd);\n"
"    exit(EXIT_SUCCESS);\n"
"}\n"

#. type: SH
#: build/C/man7/inotify.7:986 build/C/man2/inotify_add_watch.2:122
#: build/C/man2/inotify_init.2:103 build/C/man2/inotify_rm_watch.2:71
#: build/C/man2/fanotify_init.2:252 build/C/man2/fanotify_mark.2:332
#: build/C/man7/fanotify.7:738
#, no-wrap
msgid "SEE ALSO"
msgstr "関連項目"

#. type: Plain text
#: build/C/man7/inotify.7:996
msgid ""
"B<inotifywait>(1), B<inotifywatch>(1), B<inotify_add_watch>(2), "
"B<inotify_init>(2), B<inotify_init1>(2), B<inotify_rm_watch>(2), B<read>(2), "
"B<stat>(2), B<fanotify>(7)"
msgstr ""
"B<inotifywait>(1), B<inotifywatch>(1), B<inotify_add_watch>(2), "
"B<inotify_init>(2), B<inotify_init1>(2), B<inotify_rm_watch>(2), B<read>(2), "
"B<stat>(2), B<fanotify>(7)"

#. type: Plain text
#: build/C/man7/inotify.7:999
msgid ""
"I<Documentation/filesystems/inotify.txt> in the Linux kernel source tree"
msgstr "Linux カーネルソース内の I<Documentation/filesystems/inotify.txt>"

#. type: SH
#: build/C/man7/inotify.7:999 build/C/man2/inotify_add_watch.2:126
#: build/C/man2/inotify_init.2:107 build/C/man2/inotify_rm_watch.2:75
#: build/C/man2/fanotify_init.2:255 build/C/man2/fanotify_mark.2:335
#: build/C/man7/fanotify.7:743
#, no-wrap
msgid "COLOPHON"
msgstr "この文書について"

#. type: Plain text
#: build/C/man7/inotify.7:1007 build/C/man2/inotify_add_watch.2:134
#: build/C/man2/inotify_init.2:115 build/C/man2/inotify_rm_watch.2:83
#: build/C/man2/fanotify_init.2:263 build/C/man2/fanotify_mark.2:343
#: build/C/man7/fanotify.7:751
msgid ""
"This page is part of release 3.68 of the Linux I<man-pages> project.  A "
"description of the project, information about reporting bugs, and the latest "
"version of this page, can be found at \\%http://www.kernel.org/doc/man-"
"pages/."
msgstr ""
"この man ページは Linux I<man-pages> プロジェクトのリリース 3.68 の一部\n"
"である。プロジェクトの説明とバグ報告に関する情報は\n"
"http://www.kernel.org/doc/man-pages/ に書かれている。"

#. type: TH
#: build/C/man2/inotify_add_watch.2:28
#, no-wrap
msgid "INOTIFY_ADD_WATCH"
msgstr "INOTIFY_ADD_WATCH"

#. type: TH
#: build/C/man2/inotify_add_watch.2:28 build/C/man2/inotify_init.2:29
#, no-wrap
msgid "2014-03-28"
msgstr "2014-03-28"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:31
msgid "inotify_add_watch - add a watch to an initialized inotify instance"
msgstr ""
"inotify_add_watch - 初期化済み inotify インスタンスに監視対象を追加する"

#. type: SH
#: build/C/man2/inotify_add_watch.2:31 build/C/man2/inotify_init.2:32
#: build/C/man2/inotify_rm_watch.2:30 build/C/man2/fanotify_init.2:27
#: build/C/man2/fanotify_mark.2:28
#, no-wrap
msgid "SYNOPSIS"
msgstr "書式"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:33 build/C/man2/inotify_rm_watch.2:32
msgid "B<#include E<lt>sys/inotify.hE<gt>>"
msgstr "B<#include E<lt>sys/inotify.hE<gt>>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:35
msgid ""
"B<int inotify_add_watch(int >I<fd>B<, const char *>I<pathname>B<, uint32_t "
">I<mask>B<);>"
msgstr ""
"B<int inotify_add_watch(int >I<fd>B<, const char *>I<pathname>B<, uint32_t "
">I<mask>B<);>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:54
msgid ""
"B<inotify_add_watch>()  adds a new watch, or modifies an existing watch, for "
"the file whose location is specified in I<pathname>; the caller must have "
"read permission for this file.  The I<fd> argument is a file descriptor "
"referring to the inotify instance whose watch list is to be modified.  The "
"events to be monitored for I<pathname> are specified in the I<mask> bit-mask "
"argument.  See B<inotify>(7)  for a description of the bits that can be set "
"in I<mask>."
msgstr ""
"B<inotify_add_watch>()  は、 I<pathname> で指定された位置にあるファイルを監視"
"する監視アイテム (watch) の新規追加、 または既存の監視アイテムの変更を行う。 "
"呼び出し元は、監視対象のファイルに対する読み出し許可を 持っていなければならな"
"い。 I<fd> 引き数は、変更を行う監視対象リスト (watch list) を持つ inotify イ"
"ンスタンスを参照するファイルディスクリプタである。 I<pathname> のどのイベント"
"を監視するかは、引き数のビットマスク I<mask> で指定する。 I<mask> に設定でき"
"るビットの説明については B<inotify>(7)  を参照のこと。"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:68
msgid ""
"A successful call to B<inotify_add_watch>()  returns the unique watch "
"descriptor associated with I<pathname> for this inotify instance.  If "
"I<pathname> was not previously being watched by this inotify instance, then "
"the watch descriptor is newly allocated.  If I<pathname> was already being "
"watched, then the descriptor for the existing watch is returned."
msgstr ""
"B<inotify_add_watch>()  の呼び出しが成功すると、変更対象の inotify インスタン"
"スで I<pathname> に対応付けられる一意な監視対象ディスクリプタ (watch "
"descriptor) を返す。 I<pathname> がその inotify インスタンスに追加されていな"
"ければ、 監視対象ディスクリプタが新規に割り当てられる。 I<pathname> がすでに"
"監視対象になっていれば、既存の監視アイテムに対する ディスクリプタが返される。"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:79
msgid ""
"The watch descriptor is returned by later B<read>(2)s from the inotify file "
"descriptor.  These reads fetch I<inotify_event> structures (see "
"B<inotify>(7))  indicating filesystem events; the watch descriptor inside "
"this structure identifies the object for which the event occurred."
msgstr ""
"これ以降に inotify ファイルディスクリプタから B<read>(2)  を行うと、監視対象"
"ディスクリプタが返される。 これらの B<read>()  を行うと、ファイルシステムイベ"
"ントを示す I<inotify_event> 構造体が読み出される (B<inotify>(7)  参照)。この"
"構造体内の監視対象ディスクリプタにより、 どのオブジェクトでそのイベントが発生"
"したかを特定できる。"

#. type: SH
#: build/C/man2/inotify_add_watch.2:79 build/C/man2/inotify_init.2:74
#: build/C/man2/inotify_rm_watch.2:48 build/C/man2/fanotify_init.2:199
#: build/C/man2/fanotify_mark.2:236
#, no-wrap
msgid "RETURN VALUE"
msgstr "返り値"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:86
msgid ""
"On success, B<inotify_add_watch>()  returns a nonnegative watch descriptor.  "
"On error, -1 is returned and I<errno> is set appropriately."
msgstr ""
"成功すると、 B<inotify_add_watch>()  は非負の監視対象ディスクリプタを返す。 "
"エラーの場合、-1 を返し、 I<errno> を適切に設定する。"

#. type: SH
#: build/C/man2/inotify_add_watch.2:86 build/C/man2/inotify_init.2:79
#: build/C/man2/inotify_rm_watch.2:55 build/C/man2/fanotify_init.2:206
#: build/C/man2/fanotify_mark.2:243 build/C/man7/fanotify.7:394
#, no-wrap
msgid "ERRORS"
msgstr "エラー"

#. type: TP
#: build/C/man2/inotify_add_watch.2:87
#, no-wrap
msgid "B<EACCES>"
msgstr "B<EACCES>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:90
msgid "Read access to the given file is not permitted."
msgstr "指定されたファイルに対する読み出しアクセスが許可されていない。"

#. type: TP
#: build/C/man2/inotify_add_watch.2:90 build/C/man2/inotify_rm_watch.2:56
#: build/C/man2/fanotify_mark.2:244
#, no-wrap
msgid "B<EBADF>"
msgstr "B<EBADF>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:93
msgid "The given file descriptor is not valid."
msgstr "指定されたファイルディスクリプタが有効ではない。"

#. type: TP
#: build/C/man2/inotify_add_watch.2:93
#, no-wrap
msgid "B<EFAULT>"
msgstr "B<EFAULT>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:97
msgid "I<pathname> points outside of the process's accessible address space."
msgstr ""
"I<pathname> が指すアドレスがプロセスがアクセスできるアドレス空間外である。"

#. type: TP
#: build/C/man2/inotify_add_watch.2:97 build/C/man2/inotify_init.2:80
#: build/C/man2/inotify_rm_watch.2:60 build/C/man2/fanotify_init.2:207
#: build/C/man2/fanotify_mark.2:248 build/C/man2/fanotify_mark.2:257
#: build/C/man7/fanotify.7:399 build/C/man7/fanotify.7:433
#, no-wrap
msgid "B<EINVAL>"
msgstr "B<EINVAL>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:102
msgid ""
"The given event mask contains no valid events; or I<fd> is not an inotify "
"file descriptor."
msgstr ""
"指定されたイベントマスクに有効なイベントが含まれていない。 もしくは I<fd> が "
"inotify ファイルディスクリプタではない。"

#. type: TP
#: build/C/man2/inotify_add_watch.2:102
#, no-wrap
msgid "B<ENAMETOOLONG>"
msgstr "B<ENAMETOOLONG>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:106
msgid "I<pathname> is too long."
msgstr "I<pathname> が長過ぎる。"

#. type: TP
#: build/C/man2/inotify_add_watch.2:106 build/C/man2/fanotify_mark.2:265
#: build/C/man7/fanotify.7:439
#, no-wrap
msgid "B<ENOENT>"
msgstr "B<ENOENT>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:111
msgid ""
"A directory component in I<pathname> does not exist or is a dangling "
"symbolic link."
msgstr ""
"I<pathname> のディレクトリ部分の構成要素が、存在しないか、\n"
"リンク切れのシンボリックリンクである。"

#. type: TP
#: build/C/man2/inotify_add_watch.2:111 build/C/man2/inotify_init.2:91
#: build/C/man2/fanotify_init.2:219 build/C/man2/fanotify_mark.2:274
#, no-wrap
msgid "B<ENOMEM>"
msgstr "B<ENOMEM>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:114
msgid "Insufficient kernel memory was available."
msgstr "カーネルメモリが十分になかった。"

#. type: TP
#: build/C/man2/inotify_add_watch.2:114 build/C/man2/fanotify_mark.2:277
#, no-wrap
msgid "B<ENOSPC>"
msgstr "B<ENOSPC>"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:118
msgid ""
"The user limit on the total number of inotify watches was reached or the "
"kernel failed to allocate a needed resource."
msgstr ""
"inotify 監視対象の総数がユーザが追加できる上限に達していた。 もしくは、必要な"
"資源の割り当てにカーネルが失敗した。"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:120 build/C/man2/inotify_rm_watch.2:69
msgid "Inotify was merged into the 2.6.13 Linux kernel."
msgstr "inotify は Linux カーネル 2.6.13 に組み込まれた。"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:122 build/C/man2/inotify_rm_watch.2:71
#: build/C/man2/fanotify_init.2:239 build/C/man2/fanotify_mark.2:305
msgid "This system call is Linux-specific."
msgstr "このシステムコールは Linux 独自である。"

#. type: Plain text
#: build/C/man2/inotify_add_watch.2:126
msgid "B<inotify_init>(2), B<inotify_rm_watch>(2), B<inotify>(7)"
msgstr "B<inotify_init>(2), B<inotify_rm_watch>(2), B<inotify>(7)"

#. type: TH
#: build/C/man2/inotify_init.2:29
#, no-wrap
msgid "INOTIFY_INIT"
msgstr "INOTIFY_INIT"

#. type: Plain text
#: build/C/man2/inotify_init.2:32
msgid "inotify_init, inotify_init1 - initialize an inotify instance"
msgstr "inotify_init, inotify_init1 - inotify インスタンスを初期化する"

#. type: Plain text
#: build/C/man2/inotify_init.2:35
#, no-wrap
msgid "B<#include E<lt>sys/inotify.hE<gt>>\n"
msgstr "B<#include E<lt>sys/inotify.hE<gt>>\n"

#. type: Plain text
#: build/C/man2/inotify_init.2:38
#, no-wrap
msgid ""
"B<int inotify_init(void);>\n"
"B<int inotify_init1(int >I<flags>B<);>\n"
msgstr ""
"B<int inotify_init(void);>\n"
"B<int inotify_init1(int >I<flags>B<);>\n"

#. type: Plain text
#: build/C/man2/inotify_init.2:42
msgid "For an overview of the inotify API, see B<inotify>(7)."
msgstr "inotify API の概要については B<inotify>(7) を参照。"

#. type: Plain text
#: build/C/man2/inotify_init.2:46
msgid ""
"B<inotify_init>()  initializes a new inotify instance and returns a file "
"descriptor associated with a new inotify event queue."
msgstr ""
"B<inotify_init>()  は、新規の inotify インスタンスを初期化し、作成された "
"inotify イベントキュー に対応するファイルディスクリプタを返す。"

#. type: Plain text
#: build/C/man2/inotify_init.2:56
msgid ""
"If I<flags> is 0, then B<inotify_init1>()  is the same as "
"B<inotify_init>().  The following values can be bitwise ORed in I<flags> to "
"obtain different behavior:"
msgstr ""
"B<inotify_init1>()  は、 I<flags> が 0 の場合、 B<inotify_init>()  と同じであ"
"る。 I<flags> に以下の値をビット毎の論理和 (OR) で指定することで、 異なる動作"
"をさせることができる。"

#. type: TP
#: build/C/man2/inotify_init.2:56
#, no-wrap
msgid "B<IN_NONBLOCK>"
msgstr "B<IN_NONBLOCK>"

#. type: Plain text
#: build/C/man2/inotify_init.2:64
msgid ""
"Set the B<O_NONBLOCK> file status flag on the new open file description.  "
"Using this flag saves extra calls to B<fcntl>(2)  to achieve the same result."
msgstr ""
"新しく生成されるオープンファイル記述 (open file description) の BR "
"O_NONBLOCK ファイルステータスフラグをセットする。 このフラグを使うことで、 "
"B<O_NONBLOCK> をセットするために B<fcntl>(2)  を追加で呼び出す必要がなくな"
"る。"

#. type: TP
#: build/C/man2/inotify_init.2:64
#, no-wrap
msgid "B<IN_CLOEXEC>"
msgstr "B<IN_CLOEXEC>"

#. type: Plain text
#: build/C/man2/inotify_init.2:74
msgid ""
"Set the close-on-exec (B<FD_CLOEXEC>)  flag on the new file descriptor.  See "
"the description of the B<O_CLOEXEC> flag in B<open>(2)  for reasons why this "
"may be useful."
msgstr ""
"新しいファイル・ディスクリプターに対して close-on-exec (B<FD_CLOEXEC>)  フラ"
"グをセットする。 このフラグが役に立つ理由については、 B<open>(2)  の "
"B<O_CLOEXEC> フラグの説明を参照のこと。"

#. type: Plain text
#: build/C/man2/inotify_init.2:79
msgid ""
"On success, these system calls return a new file descriptor.  On error, -1 "
"is returned, and I<errno> is set to indicate the error."
msgstr ""
"成功すると、これらのシステムコールは新しいファイルディスクリプタを返す。 エ"
"ラーの場合、-1 を返し、 I<errno> をエラーを示す値に設定する。"

#. type: Plain text
#: build/C/man2/inotify_init.2:85
msgid "(B<inotify_init1>())  An invalid value was specified in I<flags>."
msgstr "(B<inotify_init1>())  無効な値が I<flags> に指定された。"

#. type: TP
#: build/C/man2/inotify_init.2:85 build/C/man2/fanotify_init.2:216
#: build/C/man7/fanotify.7:402
#, no-wrap
msgid "B<EMFILE>"
msgstr "B<EMFILE>"

#. type: Plain text
#: build/C/man2/inotify_init.2:88
msgid ""
"The user limit on the total number of inotify instances has been reached."
msgstr "inotify インスタンスの総数がユーザ単位の上限に達していた。"

#. type: TP
#: build/C/man2/inotify_init.2:88 build/C/man7/fanotify.7:409
#, no-wrap
msgid "B<ENFILE>"
msgstr "B<ENFILE>"

#. type: Plain text
#: build/C/man2/inotify_init.2:91
msgid ""
"The system limit on the total number of file descriptors has been reached."
msgstr "inotify インスタンスの総数がシステムの上限に達していた。"

#. type: Plain text
#: build/C/man2/inotify_init.2:94
msgid "Insufficient kernel memory is available."
msgstr "カーネルメモリが十分になかった。"

#. type: Plain text
#: build/C/man2/inotify_init.2:101
msgid ""
"B<inotify_init>()  first appeared in Linux 2.6.13; library support was added "
"to glibc in version 2.4.  B<inotify_init1>()  was added in Linux 2.6.27; "
"library support was added to glibc in version 2.9."
msgstr ""
"B<inotify_init>()  は Linux 2.6.13 で初めて登場し、\n"
"ライブラリによるサポートは glibc バージョン 2.4 で追加された。\n"
"B<inotify_init1>()  は Linux 2.6.27 で追加され、\n"
"ライブラリによるサポートは glibc バージョン 2.9 で追加された。"

#. type: Plain text
#: build/C/man2/inotify_init.2:103
msgid "These system calls are Linux-specific."
msgstr "これらのシステムコールは Linux 独自である。"

#. type: Plain text
#: build/C/man2/inotify_init.2:107
msgid "B<inotify_add_watch>(2), B<inotify_rm_watch>(2), B<inotify>(7)"
msgstr "B<inotify_add_watch>(2), B<inotify_rm_watch>(2), B<inotify>(7)"

#. type: TH
#: build/C/man2/inotify_rm_watch.2:27
#, no-wrap
msgid "INOTIFY_RM_WATCH"
msgstr "INOTIFY_RM_WATCH"

#. type: TH
#: build/C/man2/inotify_rm_watch.2:27
#, no-wrap
msgid "2010-10-15"
msgstr "2010-10-15"

#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:30
msgid "inotify_rm_watch - remove an existing watch from an inotify instance"
msgstr ""
"inotify_rm_watch - inotify インスタンスから既存の監視アイテムを削除する"

#.  Before glibc 2.10, the second argument was types as uint32_t.
#.  http://sources.redhat.com/bugzilla/show_bug.cgi?id=7040
#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:36
msgid "B<int inotify_rm_watch(int >I<fd>B<, int >I<wd>B<);>"
msgstr "B<int inotify_rm_watch(int >I<fd>B<, int >I<wd>B<);>"

#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:42
msgid ""
"B<inotify_rm_watch>()  removes the watch associated with the watch "
"descriptor I<wd> from the inotify instance associated with the file "
"descriptor I<fd>."
msgstr ""
"B<inotify_rm_watch>()  は、監視対象ディスクリプタ (watch descriptor)  I<wd> "
"に対応する監視アイテムを、 ファイルディスクリプタ I<fd> に対応する inotify イ"
"ンスタンスから削除する。"

#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:48
msgid ""
"Removing a watch causes an B<IN_IGNORED> event to be generated for this "
"watch descriptor.  (See B<inotify>(7).)"
msgstr ""
"監視対象を削除すると、 この監視対象ディスクリプタに対して B<IN_IGNORED> イベ"
"ントが生成される (B<inotify>(7)  参照)。"

#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:55
msgid ""
"On success, B<inotify_rm_watch>()  returns zero.  On error, -1 is returned "
"and I<errno> is set to indicate the cause of the error."
msgstr ""
"成功すると、B<inotify_rm_watch>() は 0 を返す。 エラーの場合、-1 を返し、 "
"I<errno> をエラーの原因を示す値に設定する。"

#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:60
msgid "I<fd> is not a valid file descriptor."
msgstr "I<fd> が有効なファイルディスクリプタではない。"

#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:67
msgid ""
"The watch descriptor I<wd> is not valid; or I<fd> is not an inotify file "
"descriptor."
msgstr ""
"監視対象ディスクリプタ I<wd> が有効でない。もしくは、 I<fd> が inotify ファイ"
"ルディスクリプタではない。"

#. type: Plain text
#: build/C/man2/inotify_rm_watch.2:75
msgid "B<inotify_add_watch>(2), B<inotify_init>(2), B<inotify>(7)"
msgstr "B<inotify_add_watch>(2), B<inotify_init>(2), B<inotify>(7)"

#. type: TH
#: build/C/man2/fanotify_init.2:24
#, no-wrap
msgid "FANOTIFY_INIT"
msgstr "FANOTIFY_INIT"

#. type: TH
#: build/C/man2/fanotify_init.2:24
#, no-wrap
msgid "2014-05-18"
msgstr "2014-05-18"

#. type: Plain text
#: build/C/man2/fanotify_init.2:27
msgid "fanotify_init - create and initialize fanotify group"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:29
msgid "B<#include E<lt>fcntl.hE<gt>>"
msgstr "B<#include E<lt>fcntl.hE<gt>>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:31
msgid "B<#include E<lt>sys/fanotify.hE<gt>>"
msgstr "B<#include E<lt>sys/fanotify.hE<gt>>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:33
msgid ""
"B<int fanotify_init(unsigned int >I<flags>B<, unsigned int "
">I<event_f_flags>B<);>"
msgstr "B<int fanotify_init(unsigned int >I<flags>B<, unsigned int >I<event_f_flags>B<);>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:36 build/C/man2/fanotify_mark.2:39
msgid "For an overview of the fanotify API, see B<fanotify>(7)."
msgstr "fanotify API の概要については B<fanotify>(7) を参照。"

#. type: Plain text
#: build/C/man2/fanotify_init.2:40
msgid ""
"B<fanotify_init>()  initializes a new fanotify group and returns a file "
"descriptor for the event queue associated with the group."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:51
msgid ""
"The file descriptor is used in calls to B<fanotify_mark>(2)  to specify the "
"files, directories, and mounts for which fanotify events shall be created.  "
"These events are received by reading from the file descriptor.  Some events "
"are only informative, indicating that a file has been accessed.  Other "
"events can be used to determine whether another application is permitted to "
"access a file or directory.  Permission to access filesystem objects is "
"granted by writing to the file descriptor."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:54
msgid ""
"Multiple programs may be using the fanotify interface at the same time to "
"monitor the same files."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:58
msgid ""
"In the current implementation, the number of fanotify groups per user is "
"limited to 128.  This limit cannot be overridden."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:67
msgid ""
"Calling B<fanotify_init>()  requires the B<CAP_SYS_ADMIN> capability.  This "
"constraint might be relaxed in future versions of the API.  Therefore, "
"certain additional capability checks have been implemented as indicated "
"below."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:73
msgid ""
"The I<flags> argument contains a multi-bit field defining the notification "
"class of the listening application and further single bit fields specifying "
"the behavior of the file descriptor."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:77
msgid ""
"If multiple listeners for permission events exist, the notification class is "
"used to establish the sequence in which the listeners receive the events."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:80
msgid ""
"Only one of the following notification classes may be specified in I<flags>:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:80
#, no-wrap
msgid "B<FAN_CLASS_PRE_CONTENT>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:88
msgid ""
"This value allows the receipt of events notifying that a file has been "
"accessed and events for permission decisions if a file may be accessed.  It "
"is intended for event listeners that need to access files before they "
"contain their final data.  This notification class might be used by "
"hierarchical storage managers, for example."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:88
#, no-wrap
msgid "B<FAN_CLASS_CONTENT>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:96
msgid ""
"This value allows the receipt of events notifying that a file has been "
"accessed and events for permission decisions if a file may be accessed.  It "
"is intended for event listeners that need to access files when they already "
"contain their final content.  This notification class might be used by "
"malware detection programs, for example."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:96
#, no-wrap
msgid "B<FAN_CLASS_NOTIF>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:103
msgid ""
"This is the default value.  It does not need to be specified.  This value "
"only allows the receipt of events notifying that a file has been accessed.  "
"Permission decisions before the file is accessed are not possible."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:111
msgid ""
"Listeners with different notification classes will receive events in the "
"order B<FAN_CLASS_PRE_CONTENT>, B<FAN_CLASS_CONTENT>, B<FAN_CLASS_NOTIF>.  "
"The order of notification for listeners in the same notification class is "
"undefined."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:114
msgid "The following bits can additionally be set in I<flags>:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:114
#, no-wrap
msgid "B<FAN_CLOEXEC>"
msgstr "B<FAN_CLOEXEC>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:123
msgid ""
"Set the close-on-exec flag (B<FD_CLOEXEC>)  on the new file descriptor.  See "
"the description of the B<O_CLOEXEC> flag in B<open>(2)."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:123
#, no-wrap
msgid "B<FAN_NONBLOCK>"
msgstr "B<FAN_NONBLOCK>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:133
msgid ""
"Enable the nonblocking flag (B<O_NONBLOCK>)  for the file descriptor.  "
"Reading from the file descriptor will not block.  Instead, if no data is "
"available, B<read>(2)  will fail with the error B<EAGAIN>."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:133
#, no-wrap
msgid "B<FAN_UNLIMITED_QUEUE>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:139
msgid ""
"Remove the limit of 16384 events for the event queue.  Use of this flag "
"requires the B<CAP_SYS_ADMIN> capability."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:139
#, no-wrap
msgid "B<FAN_UNLIMITED_MARKS>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:145
msgid ""
"Remove the limit of 8192 marks.  Use of this flag requires the "
"B<CAP_SYS_ADMIN> capability."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:158
msgid ""
"The I<event_f_flags> argument defines the file status flags that will be set "
"on the open file descriptions that are created for fanotify events.  For "
"details of these flags, see the description of the I<flags> values in "
"B<open>(2).  I<event_f_flags> includes a multi-bit field for the access "
"mode.  This field can take the following values:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:158
#, no-wrap
msgid "B<O_RDONLY>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:161
msgid "This value allows only read access."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:161
#, no-wrap
msgid "B<O_WRONLY>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:164
msgid "This value allows only write access."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:164
#, no-wrap
msgid "B<O_RDWR>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:167
msgid "This value allows read and write access."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:171
msgid ""
"Additional bits can be set in I<event_f_flags>.  The most useful values are:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:171
#, no-wrap
msgid "B<O_LARGEFILE>"
msgstr "B<O_LARGEFILE>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:178
msgid ""
"Enable support for files exceeding 2 GB.  Failing to set this flag will "
"result in an B<EOVERFLOW> error when trying to open a large file which is "
"monitored by an fanotify group on a 32-bit system."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:178
#, no-wrap
msgid "B<O_CLOEXEC>"
msgstr "B<O_CLOEXEC>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:186
msgid ""
"Enable the close-on-exec flag for the file descriptor.  See the description "
"of the B<O_CLOEXEC> flag in B<open>(2)  for reasons why this may be useful."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:199
msgid ""
"The following are also allowable: B<O_APPEND>, B<O_DSYNC>, B<O_NOATIME>, "
"B<O_NONBLOCK>, and B<O_SYNC>.  Specifying any other flag in I<event_f_flags> "
"yields the error B<EINVAL> (but see BUGS)."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:206
msgid ""
"On success, B<fanotify_init>()  returns a new file descriptor.  On error, -1 "
"is returned, and I<errno> is set to indicate the error."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:216
msgid ""
"An invalid value was passed in I<flags> or I<event_f_flags>.  "
"B<FAN_ALL_INIT_FLAGS> defines all allowable bits for I<flags>."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:219
msgid "The number of fanotify groups for this user exceeds 128."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:222
msgid "The allocation of memory for the notification group failed."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:222 build/C/man2/fanotify_mark.2:283
#, no-wrap
msgid "B<ENOSYS>"
msgstr "B<ENOSYS>"

#. type: Plain text
#: build/C/man2/fanotify_init.2:228
msgid ""
"This kernel does not implement B<fanotify_init>().  The fanotify API is "
"available only if the kernel was configured with B<CONFIG_FANOTIFY>."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_init.2:228
#, no-wrap
msgid "B<EPERM>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:233
msgid ""
"The operation is not permitted because the caller lacks the B<CAP_SYS_ADMIN> "
"capability."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:237
msgid ""
"B<fanotify_init>()  was introduced in version 2.6.36 of the Linux kernel and "
"enabled in version 2.6.37."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:242
msgid "As of Linux 3.15, the following bug exists:"
msgstr ""

#.  FIXME: Patch accepted to mm tree.
#. type: Plain text
#: build/C/man2/fanotify_init.2:252
msgid ""
"The I<event_f_flags> argument is not checked for invalid flags.  Flags that "
"are intended only for internal use, such as B<FMODE_EXEC>, can be set, and "
"will consequently be set for the file descriptors returned when reading from "
"the fanotify file descriptor."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_init.2:255
msgid "B<fanotify_mark>(2), B<fanotify>(7)"
msgstr "B<fanotify_mark>(2), B<fanotify>(7)"

#. type: TH
#: build/C/man2/fanotify_mark.2:24
#, no-wrap
msgid "FANOTIFY_MARK"
msgstr "FANOTIFY_MARK"

#. type: TH
#: build/C/man2/fanotify_mark.2:24
#, no-wrap
msgid "2014-04-24"
msgstr "2014-04-24"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:28
msgid ""
"fanotify_mark - add, remove, or modify an fanotify mark on a filesystem "
"object"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:31
#, no-wrap
msgid "B<#include E<lt>sys/fanotify.hE<gt>>\n"
msgstr "B<#include E<lt>sys/fanotify.hE<gt>>\n"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:35
#, no-wrap
msgid ""
"B<int fanotify_mark(int >I<fanotify_fd>B<, unsigned int >I<flags>B<,>\n"
"B<                  uint64_t >I<mask>B<, int >I<dirfd>B<, const char *>I<pathname>B<);>\n"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:44
msgid ""
"B<fanotify_mark>(2)  adds, removes, or modifies an fanotify mark on a "
"filesystem object.  The caller must have read permission on the filesystem "
"object that is to be marked."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:49
msgid ""
"The I<fanotify_fd> argument is a file descriptor returned by "
"B<fanotify_init>(2)."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:53
msgid ""
"I<flags> is a bit mask describing the modification to perform.  It must "
"include exactly one of the following values:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:53
#, no-wrap
msgid "B<FAN_MARK_ADD>"
msgstr "B<FAN_MARK_ADD>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:62
msgid ""
"The events in I<mask> will be added to the mark mask (or to the ignore "
"mask).  I<mask> must be nonempty or the error B<EINVAL> will occur."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:62
#, no-wrap
msgid "B<FAN_MARK_REMOVE>"
msgstr "B<FAN_MARK_REMOVE>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:71
msgid ""
"The events in argument I<mask> will be removed from the mark mask (or from "
"the ignore mask).  I<mask> must be nonempty or the error B<EINVAL> will "
"occur."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:71
#, no-wrap
msgid "B<FAN_MARK_FLUSH>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:86
msgid ""
"Remove either all mount or all non-mount marks from the fanotify group.  If "
"I<flag> contains B<FAN_MARK_MOUNT>, all marks for mounts are removed from "
"the group.  Otherwise, all marks for directories and files are removed.  No "
"flag other than B<FAN_MARK_MOUNT> can be used in conjunction with "
"B<FAN_MARK_FLUSH>.  I<mask> is ignored."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:90
msgid ""
"If none of the values above is specified, or more than one is specified, the "
"call fails with the error B<EINVAL>."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:94
msgid ""
"In addition, zero or more of the following values may be ORed into I<flags>:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:94
#, no-wrap
msgid "B<FAN_MARK_DONT_FOLLOW>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:105
msgid ""
"If I<pathname> is a symbolic link, mark the link itself, rather than the "
"file to which it refers.  (By default, B<fanotify_mark>()  dereferences "
"I<pathname> if it is a symbolic link.)"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:105
#, no-wrap
msgid "B<FAN_MARK_ONLYDIR>"
msgstr "B<FAN_MARK_ONLYDIR>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:110
msgid ""
"If the filesystem object to be marked is not a directory, the error "
"B<ENOTDIR> shall be raised."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:110
#, no-wrap
msgid "B<FAN_MARK_MOUNT>"
msgstr "B<FAN_MARK_MOUNT>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:121
msgid ""
"Mark the mount point specified by I<pathname>.  If I<pathname> is not itself "
"a mount point, the mount point containing I<pathname> will be marked.  All "
"directories, subdirectories, and the contained files of the mount point will "
"be monitored."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:121
#, no-wrap
msgid "B<FAN_MARK_IGNORED_MASK>"
msgstr "B<FAN_MARK_IGNORED_MASK>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:126
msgid ""
"The events in I<mask> shall be added to or removed from the ignore mask."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:126
#, no-wrap
msgid "B<FAN_MARK_IGNORED_SURV_MODIFY>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:132
msgid ""
"The ignore mask shall survive modify events.  If this flag is not set, the "
"ignore mask is cleared when a modify event occurs for the ignored file or "
"directory."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:136
msgid ""
"I<mask> defines which events shall be listened for (or which shall be "
"ignored).  It is a bit mask composed of the following values:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:136 build/C/man7/fanotify.7:246
#, no-wrap
msgid "B<FAN_ACCESS>"
msgstr "B<FAN_ACCESS>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:139
msgid ""
"Create an event when a file or directory (but see BUGS) is accessed (read)."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:139 build/C/man7/fanotify.7:252
#, no-wrap
msgid "B<FAN_MODIFY>"
msgstr "B<FAN_MODIFY>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:142
msgid "Create an event when a file is modified (write)."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:142 build/C/man7/fanotify.7:255
#, no-wrap
msgid "B<FAN_CLOSE_WRITE>"
msgstr "B<FAN_CLOSE_WRITE>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:145
msgid "Create an event when a writable file is closed."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:145 build/C/man7/fanotify.7:262
#, no-wrap
msgid "B<FAN_CLOSE_NOWRITE>"
msgstr "B<FAN_CLOSE_NOWRITE>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:148
msgid "Create an event when a read-only file or directory is closed."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:148 build/C/man7/fanotify.7:249
#, no-wrap
msgid "B<FAN_OPEN>"
msgstr "B<FAN_OPEN>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:151
msgid "Create an event when a file or directory is opened."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:151 build/C/man7/fanotify.7:283
#, no-wrap
msgid "B<FAN_OPEN_PERM>"
msgstr "B<FAN_OPEN_PERM>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:159
msgid ""
"Create an event when a permission to open a file or directory is requested.  "
"An fanotify file descriptor created with B<FAN_CLASS_PRE_CONTENT> or "
"B<FAN_CLASS_CONTENT> is required."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:159 build/C/man7/fanotify.7:274
#, no-wrap
msgid "B<FAN_ACCESS_PERM>"
msgstr "B<FAN_ACCESS_PERM>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:167
msgid ""
"Create an event when a permission to read a file or directory is requested.  "
"An fanotify file descriptor created with B<FAN_CLASS_PRE_CONTENT> or "
"B<FAN_CLASS_CONTENT> is required."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:167
#, no-wrap
msgid "B<FAN_ONDIR>"
msgstr "B<FAN_ONDIR>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:176
msgid ""
"Create events for directories\\(emfor example, when B<opendir>(2), "
"B<readdir>(2)  (but see BUGS), and B<closedir>(2)  are called.  Without this "
"flag, only events for files are created."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:176
#, no-wrap
msgid "B<FAN_EVENT_ON_CHILD>"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:184
msgid ""
"Events for the immediate children of marked directories shall be created.  "
"The flag has no effect when marking mounts.  Note that events are not "
"generated for children of the subdirectories of marked directories.  To "
"monitor complete directory trees it is necessary to mark the relevant mount."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:186
msgid "The following composed value is defined:"
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:186 build/C/man7/fanotify.7:290
#, no-wrap
msgid "B<FAN_CLOSE>"
msgstr "B<FAN_CLOSE>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:190
msgid "A file is closed (B<FAN_CLOSE_WRITE>|B<FAN_CLOSE_NOWRITE>)."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:195
msgid ""
"The filesystem object to be marked is determined by the file descriptor "
"I<dirfd> and the pathname specified in I<pathname>:"
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:201
msgid ""
"If I<pathname> is NULL, I<dirfd> defines the filesystem object to be marked."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:209
msgid ""
"If I<pathname> is NULL, and I<dirfd> takes the special value B<AT_FDCWD>, "
"the current working directory is to be marked."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:215
msgid ""
"If I<pathname> is absolute, it defines the filesystem object to be marked, "
"and I<dirfd> is ignored."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:226
msgid ""
"If I<pathname> is relative, and I<dirfd> does not have the value "
"B<AT_FDCWD>, then the filesystem object to be marked is determined by "
"interpreting I<pathname> relative the directory referred to by I<dirfd>."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:236
msgid ""
"If I<pathname> is relative, and I<dirfd> has the value B<AT_FDCWD,> then the "
"filesystem object to be marked is determined by interpreting I<pathname> "
"relative the current working directory."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:243
msgid ""
"On success, B<fanotify_mark>()  returns 0.  On error, -1 is returned, and "
"I<errno> is set to indicate the error."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:248
msgid "An invalid file descriptor was passed in I<fanotify_fd>."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:257
msgid ""
"An invalid value was passed in I<flags> or I<mask>, or I<fanotify_fd> was "
"not an fanotify file descriptor."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:265
msgid ""
"The fanotify file descriptor was opened with B<FAN_CLASS_NOTIF> and mask "
"contains a flag for permission events (B<FAN_OPEN_PERM> or "
"B<FAN_ACCESS_PERM>)."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:274
msgid ""
"The filesystem object indicated by I<dirfd> and I<pathname> does not exist.  "
"This error also occurs when trying to remove a mark from an object which is "
"not marked."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:277
msgid "The necessary memory could not be allocated."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:283
msgid ""
"The number of marks exceeds the limit of 8192 and the B<FAN_UNLIMITED_MARKS> "
"flag was not specified when the fanotify file descriptor was created with "
"B<fanotify_init>(2)."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:289
msgid ""
"This kernel does not implement B<fanotify_mark>().  The fanotify API is "
"available only if the kernel was configured with B<CONFIG_FANOTIFY>."
msgstr ""

#. type: TP
#: build/C/man2/fanotify_mark.2:289
#, no-wrap
msgid "B<ENOTDIR>"
msgstr "B<ENOTDIR>"

#. type: Plain text
#: build/C/man2/fanotify_mark.2:299
msgid ""
"I<flags> contains B<FAN_MARK_ONLYDIR>, and I<dirfd> and I<pathname> do not "
"specify a directory."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:303
msgid ""
"B<fanotify_mark>()  was introduced in version 2.6.36 of the Linux kernel and "
"enabled in version 2.6.37."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:308 build/C/man7/fanotify.7:490
msgid "As of Linux 3.15, the following bugs exist:"
msgstr ""

#.  FIXME: Patch is in next-20140424.
#. type: Plain text
#: build/C/man2/fanotify_mark.2:318
msgid ""
"If I<flags> contains B<FAN_MARK_FLUSH>, I<dirfd> and I<pathname> must "
"specify a valid filesystem object, even though this object is not used."
msgstr ""

#.  FIXME: Patch is in next-20140424.
#. type: Plain text
#: build/C/man2/fanotify_mark.2:324
msgid "B<readdir>(2)  does not generate a B<FAN_ACCESS> event."
msgstr ""

#.  FIXME: Patch proposed.
#. type: Plain text
#: build/C/man2/fanotify_mark.2:332
msgid ""
"If B<fanotify_mark>(2)  is called with B<FAN_MARK_FLUSH,> I<flags> is not "
"checked for invalid values."
msgstr ""

#. type: Plain text
#: build/C/man2/fanotify_mark.2:335
msgid "B<fanotify_init>(2), B<fanotify>(7)"
msgstr "B<fanotify_init>(2), B<fanotify>(7)"

#. type: TH
#: build/C/man7/fanotify.7:25
#, no-wrap
msgid "FANOTIFY"
msgstr "FANOTIFY"

#. type: TH
#: build/C/man7/fanotify.7:25
#, no-wrap
msgid "2014-05-21"
msgstr "2014-05-21"

#. type: Plain text
#: build/C/man7/fanotify.7:28
msgid "fanotify - monitoring filesystem events"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:37
msgid ""
"The fanotify API provides notification and interception of filesystem "
"events.  Use cases include virus scanning and hierarchical storage "
"management.  Currently, only a limited set of events is supported.  In "
"particular, there is no support for create, delete, and move events.  (See "
"B<inotify>(7)  for details of an API that does notify those events.)"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:44
msgid ""
"Additional capabilities compared to the B<inotify>(7)  API include the "
"ability to monitor all of the objects in a mounted filesystem, the ability "
"to make access permission decisions, and the possibility to read or modify "
"files before access by other applications."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:52
msgid ""
"The following system calls are used with this API: B<fanotify_init>(2), "
"B<fanotify_mark>(2), B<read>(2), B<write>(2), and B<close>(2)."
msgstr ""

#. type: SS
#: build/C/man7/fanotify.7:52
#, no-wrap
msgid "fanotify_init(), fanotify_mark(), and notification groups"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:57
msgid ""
"The B<fanotify_init>(2)  system call creates and initializes an fanotify "
"notification group and returns a file descriptor referring to it."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:61
msgid ""
"An fanotify notification group is a kernel-internal object that holds a list "
"of files, directories, and mount points for which events shall be created."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:72
msgid ""
"For each entry in an fanotify notification group, two bit masks exist: the "
"I<mark> mask and the I<ignore> mask.  The mark mask defines file activities "
"for which an event shall be created.  The ignore mask defines activities for "
"which no event shall be generated.  Having these two types of masks permits "
"a mount point or directory to be marked for receiving events, while at the "
"same time ignoring events for specific objects under that mount point or "
"directory."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:78
msgid ""
"The B<fanotify_mark>(2)  system call adds a file, directory, or mount to a "
"notification group and specifies which events shall be reported (or "
"ignored), or removes or modifies such an entry."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:91
msgid ""
"A possible usage of the ignore mask is for a file cache.  Events of interest "
"for a file cache are modification of a file and closing of the same.  Hence, "
"the cached directory or mount point is to be marked to receive these "
"events.  After receiving the first event informing that a file has been "
"modified, the corresponding cache entry will be invalidated.  No further "
"modification events for this file are of interest until the file is closed.  "
"Hence, the modify event can be added to the ignore mask.  Upon receiving the "
"close event, the modify event can be removed from the ignore mask and the "
"file cache entry can be updated."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:98
msgid ""
"The entries in the fanotify notification groups refer to files and "
"directories via their inode number and to mounts via their mount ID.  If "
"files or directories are renamed or moved, the respective entries survive.  "
"If files or directories are deleted or mounts are unmounted, the "
"corresponding entries are deleted."
msgstr ""

#. type: SS
#: build/C/man7/fanotify.7:98
#, no-wrap
msgid "The event queue"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:107
msgid ""
"As events occur on the filesystem objects monitored by a notification group, "
"the fanotify system generates events that are collected in a queue.  These "
"events can then be read (using B<read>(2)  or similar)  from the fanotify "
"file descriptor returned by B<fanotify_init>(2)."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:121
msgid ""
"Two types of events are generated: I<notification> events and I<permission> "
"events.  Notification events are merely informative and require no action to "
"be taken by the receiving application except for closing the file descriptor "
"passed in the event (see below).  Permission events are requests to the "
"receiving application to decide whether permission for a file access shall "
"be granted.  For these events, the recipient must write a response which "
"decides whether access is granted or not."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:128
msgid ""
"An event is removed from the event queue of the fanotify group when it has "
"been read.  Permission events that have been read are kept in an internal "
"list of the fanotify group until either a permission decision has been taken "
"by writing to the fanotify file descriptor or the fanotify file descriptor "
"is closed."
msgstr ""

#. type: SS
#: build/C/man7/fanotify.7:128
#, no-wrap
msgid "Reading fanotify events"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:140
msgid ""
"Calling B<read>(2)  for the file descriptor returned by B<fanotify_init>(2)  "
"blocks (if the flag B<FAN_NONBLOCK> is not specified in the call to "
"B<fanotify_init>(2))  until either a file event occurs or the call is "
"interrupted by a signal (see B<signal>(7))."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:144
msgid ""
"After a successful B<read>(2), the read buffer contains one or more of the "
"following structures:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:156
#, no-wrap
msgid ""
"struct fanotify_event_metadata {\n"
"    __u32 event_len;\n"
"    __u8 vers;\n"
"    __u8 reserved;\n"
"    __u16 metadata_len;\n"
"    __aligned_u64 mask;\n"
"    __s32 fd;\n"
"    __s32 pid;\n"
"};\n"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:163
msgid ""
"For performance reasons, it is recommended to use a large buffer size (for "
"example, 4096 bytes), so that multiple events can be retrieved by a single "
"B<read>(2)."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:168
msgid ""
"The return value of B<read>(2)  is the number of bytes placed in the buffer, "
"or -1 in case of an error (but see BUGS)."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:172
msgid "The fields of the I<fanotify_event_metadata> structure are as follows:"
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:172
#, no-wrap
msgid "I<event_len>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:182
msgid ""
"This is the length of the data for the current event and the offset to the "
"next event in the buffer.  In the current implementation, the value of "
"I<event_len> is always B<FAN_EVENT_METADATA_LEN>.  However, the API is "
"designed to allow variable-length structures to be returned in the future."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:182
#, no-wrap
msgid "I<vers>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:191
msgid ""
"This field holds a version number for the structure.  It must be compared to "
"B<FANOTIFY_METADATA_VERSION> to verify that the structures returned at "
"runtime match the structures defined at compile time.  In case of a "
"mismatch, the application should abandon trying to use the fanotify file "
"descriptor."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:191
#, no-wrap
msgid "I<reserved>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:194
msgid "This field is not used."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:194
#, no-wrap
msgid "I<metadata_len>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:200
msgid ""
"This is the length of the structure.  The field was introduced to facilitate "
"the implementation of optional headers per event type.  No such optional "
"headers exist in the current implementation."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:200
#, no-wrap
msgid "I<mask>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:203
msgid "This is a bit mask describing the event (see below)."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:203 build/C/man7/fanotify.7:360
#, no-wrap
msgid "I<fd>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:211
msgid ""
"This is an open file descriptor for the object being accessed, or "
"B<FAN_NOFD> if a queue overflow occurred.  The file descriptor can be used "
"to access the contents of the monitored file or directory.  The reading "
"application is responsible for closing this file descriptor."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:224
msgid ""
"When calling B<fanotify_init>(2), the caller may specify (via the "
"I<event_f_flags> argument) various file status flags that are to be set on "
"the open file description that corresponds to this file descriptor.  In "
"addition, the (kernel-internal)  B<FMODE_NONOTIFY> file status flag is set "
"on the open file description.  This flag suppresses fanotify event "
"generation.  Hence, when the receiver of the fanotify event accesses the "
"notified file or directory using this file descriptor, no additional events "
"will be created."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:224
#, no-wrap
msgid "I<pid>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:232
msgid ""
"This is the ID of the process that caused the event.  A program listening to "
"fanotify events can compare this PID to the PID returned by B<getpid>(2), to "
"determine whether the event is caused by the listener itself, or is due to a "
"file access by another process."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:242
msgid ""
"The bit mask in I<mask> indicates which events have occurred for a single "
"filesystem object.  Multiple bits may be set in this mask, if more than one "
"event occurred for the monitored filesystem object.  In particular, "
"consecutive events for the same filesystem object and originating from the "
"same process may be merged into a single event, with the exception that two "
"permission events are never merged into one queue entry."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:246
msgid "The bits that may appear in I<mask> are as follows:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:249
msgid "A file or a directory (but see BUGS) was accessed (read)."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:252
msgid "A file or a directory was opened."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:255
msgid "A file was modified."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:262
msgid ""
"A file that was opened for writing (B<O_WRONLY> or B<O_RDWR>)  was closed."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:267
msgid ""
"A file or directory that was opened read-only (B<O_RDONLY>)  was closed."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:267
#, no-wrap
msgid "B<FAN_Q_OVERFLOW>"
msgstr "B<FAN_Q_OVERFLOW>"

#. type: Plain text
#: build/C/man7/fanotify.7:274
msgid ""
"The event queue exceeded the limit of 16384 entries.  This limit can be "
"overridden by specifying the B<FAN_UNLIMITED_QUEUE> flag when calling "
"B<fanotify_init>(2)."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:283
msgid ""
"An application wants to read a file or directory, for example using "
"B<read>(2)  or B<readdir>(2).  The reader must write a response (as "
"described below)  that determines whether the permission to access the "
"filesystem object shall be granted."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:288
msgid ""
"An application wants to open a file or directory.  The reader must write a "
"response that determines whether the permission to open the filesystem "
"object shall be granted."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:290
msgid "To check for any close event, the following bit mask may be used:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:294
msgid "A file was closed.  This is a synonym for:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:296
#, no-wrap
msgid "    FAN_CLOSE_WRITE | FAN_CLOSE_NOWRITE\n"
msgstr "    FAN_CLOSE_WRITE | FAN_CLOSE_NOWRITE\n"

#. type: Plain text
#: build/C/man7/fanotify.7:301
msgid ""
"The following macros are provided to iterate over a buffer containing "
"fanotify event metadata returned by a B<read>(2)  from an fanotify file "
"descriptor:"
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:301
#, no-wrap
msgid "B<FAN_EVENT_OK(meta, len)>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:310
msgid ""
"This macro checks the remaining length I<len> of the buffer I<meta> against "
"the length of the metadata structure and the I<event_len> field of the first "
"metadata structure in the buffer."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:310
#, no-wrap
msgid "B<FAN_EVENT_NEXT(meta, len)>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:329
msgid ""
"This macro uses the length indicated in the I<event_len> field of the "
"metadata structure pointed to by I<meta> to calculate the address of the "
"next metadata structure that follows I<meta>.  I<len> is the number of bytes "
"of metadata that currently remain in the buffer.  The macro returns a "
"pointer to the next metadata structure that follows I<meta>, and reduces "
"I<len> by the number of bytes in the the metadata structure that has been "
"skipped over (i.e., it subtracts I<meta-E<gt>event_len> from I<len>)."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:331
msgid "In addition, there is:"
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:331
#, no-wrap
msgid "B<FAN_EVENT_METADATA_LEN>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:337
msgid ""
"This macro returns the size (in bytes) of the structure "
"I<fanotify_event_metadata>.  This is the minimum size (and currently the "
"only size) of any event metadata."
msgstr ""

#. type: SS
#: build/C/man7/fanotify.7:337
#, no-wrap
msgid "Monitoring an fanotify file descriptor for events"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:344
msgid ""
"When an fanotify event occurs, the fanotify file descriptor indicates as "
"readable when passed to B<epoll>(7), B<poll>(2), or B<select>(2)."
msgstr ""

#. type: SS
#: build/C/man7/fanotify.7:344
#, no-wrap
msgid "Dealing with permission events"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:349
msgid ""
"For permission events, the application must B<write>(2)  a structure of the "
"following form to the fanotify file descriptor:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:356
#, no-wrap
msgid ""
"struct fanotify_response {\n"
"    __s32 fd;\n"
"    __u32 response;\n"
"};\n"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:360
msgid "The fields of this structure are as follows:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:364
msgid ""
"This is the file descriptor from the structure I<fanotify_event_metadata>."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:364
#, no-wrap
msgid "I<response>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:372
msgid ""
"This field indicates whether or not the permission is to be granted.  Its "
"value must be either B<FAN_ALLOW> to allow the file operation or B<FAN_DENY> "
"to deny the file operation."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:376
msgid ""
"If access is denied, the requesting application call will receive an "
"B<EPERM> error."
msgstr ""

#. type: SS
#: build/C/man7/fanotify.7:376
#, no-wrap
msgid "Closing the fanotify file descriptor"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:384
msgid ""
"When all file descriptors referring to the fanotify notification group are "
"closed, the fanotify group is released and its resources are freed for reuse "
"by the kernel.  Upon B<close>(2), outstanding permission events will be set "
"to allowed."
msgstr ""

#. type: SS
#: build/C/man7/fanotify.7:384
#, no-wrap
msgid "/proc/[pid]/fdinfo"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:394
msgid ""
"The file I</proc/[pid]/fdinfo/[fd]> contains information about fanotify "
"marks for file descriptor I<fd> of process I<pid>.  See the kernel source "
"file I<Documentation/filesystems/proc.txt> for details."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:399
msgid ""
"In addition to the usual errors for B<read>(2), the following errors can "
"occur when reading from the fanotify file descriptor:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:402
msgid "The buffer is too small to hold the event."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:409
msgid ""
"The per-process limit on the number of open files has been reached.  See the "
"description of B<RLIMIT_NOFILE> in B<getrlimit>(2)."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:416
msgid ""
"The system-wide limit on the number of open files has been reached.  See I</"
"proc/sys/fs/file-max> in B<proc>(5)."
msgstr ""

#. type: TP
#: build/C/man7/fanotify.7:416
#, no-wrap
msgid "B<ETXTBSY>"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:429
msgid ""
"This error is returned by B<read>(2)  if B<O_RDWR> or B<O_WRONLY> was "
"specified in the I<event_f_flags> argument when calling B<fanotify_init>(2)  "
"and an event occurred for a monitored file that is currently being executed."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:433
msgid ""
"In addition to the usual errors for B<write>(2), the following errors can "
"occur when writing to the fanotify file descriptor:"
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:439
msgid ""
"Fanotify access permissions are not enabled in the kernel configuration or "
"the value of I<response> in the response structure is not valid."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:446
msgid ""
"The file descriptor I<fd> in the response structure is not valid.  This may "
"occur when a response for the permission event has already been written."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:450
msgid ""
"The fanotify API was introduced in version 2.6.36 of the Linux kernel and "
"enabled in version 2.6.37.  Fdinfo support was added in version 3.8."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:452
msgid "The fanotify API is Linux-specific."
msgstr "fanotify API は Linux 独自のものである。"

#. type: Plain text
#: build/C/man7/fanotify.7:459
msgid ""
"The fanotify API is available only if the kernel was built with the "
"B<CONFIG_FANOTIFY> configuration option enabled.  In addition, fanotify "
"permission handling is available only if the "
"B<CONFIG_FANOTIFY_ACCESS_PERMISSIONS> configuration option is enabled."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:464
msgid ""
"Fanotify reports only events that a user-space program triggers through the "
"filesystem API.  As a result, it does not catch remote events that occur on "
"network filesystems."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:471
msgid ""
"The fanotify API does not report file accesses and modifications that may "
"occur because of B<mmap>(2), B<msync>(2), and B<munmap>(2)."
msgstr "inotify API は B<mmap>(2), B<msync>(2), B<munmap>(2) により起こったファイルのアクセスと変更を報告しない。"

#. type: Plain text
#: build/C/man7/fanotify.7:476
msgid ""
"Events for directories are created only if the directory itself is opened, "
"read, and closed.  Adding, removing, or changing children of a marked "
"directory does not create events for the monitored directory itself."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:484
msgid ""
"Fanotify monitoring of directories is not recursive: to monitor "
"subdirectories under a directory, additional marks must be created.  (But "
"note that the fanotify API provides no way of detecting when a subdirectory "
"has been created under a marked directory, which makes recursive monitoring "
"difficult.)  Monitoring mounts offers the capability to monitor a whole "
"directory tree."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:487
msgid "The event queue can overflow.  In this case, events are lost."
msgstr ""

#.  FIXME: A patch was proposed.
#. type: Plain text
#: build/C/man7/fanotify.7:499
msgid ""
"When an event is generated, no check is made to see whether the user ID of "
"the receiving process has authorization to read or write the file before "
"passing a file descriptor for that file.  This poses a security risk, when "
"the B<CAP_SYS_ADMIN> capability is set for programs executed by unprivileged "
"users."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:509
msgid ""
"If a call to B<read>(2)  processes multiple events from the fanotify queue "
"and an error occurs, the return value will be the total length of the events "
"successfully copied to the user-space buffer before the error occurred.  The "
"return value will not be -1, and I<errno> will not be set.  Thus, the "
"reading application has no way to detect the error."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:519
msgid ""
"The following program demonstrates the usage of the fanotify API.  It marks "
"the mount point passed as a command-line argument and waits for events of "
"type B<FAN_PERM_OPEN> and B<FAN_CLOSE_WRITE>.  When a permission event "
"occurs, a B<FAN_ALLOW> response is given."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:529
msgid ""
"The following output was recorded while editing the file I</home/user/temp/"
"notes>.  Before the file was opened, a B<FAN_OPEN_PERM> event occurred.  "
"After the file was closed, a B<FAN_CLOSE_WRITE> event occurred.  Execution "
"of the program ends when the user presses the ENTER key."
msgstr ""

#. type: Plain text
#: build/C/man7/fanotify.7:537
#, no-wrap
msgid ""
"# ./fanotify_example /home\n"
"Press enter key to terminate.\n"
"Listening for events.\n"
"FAN_OPEN_PERM: File /home/user/temp/notes\n"
"FAN_CLOSE_WRITE: File /home/user/temp/notes\n"
msgstr ""
"# ./fanotify_example /home\n"
"Press enter key to terminate.\n"
"Listening for events.\n"
"FAN_OPEN_PERM: File /home/user/temp/notes\n"
"FAN_CLOSE_WRITE: File /home/user/temp/notes\n"

#. type: Plain text
#: build/C/man7/fanotify.7:552
#, no-wrap
msgid ""
"#define _GNU_SOURCE     /* Needed to get O_LARGEFILE definition */\n"
"#include E<lt>errno.hE<gt>\n"
"#include E<lt>fcntl.hE<gt>\n"
"#include E<lt>limits.hE<gt>\n"
"#include E<lt>poll.hE<gt>\n"
"#include E<lt>stdio.hE<gt>\n"
"#include E<lt>stdlib.hE<gt>\n"
"#include E<lt>sys/fanotify.hE<gt>\n"
"#include E<lt>unistd.hE<gt>\n"
msgstr ""
"#define _GNU_SOURCE     /* Needed to get O_LARGEFILE definition */\n"
"#include E<lt>errno.hE<gt>\n"
"#include E<lt>fcntl.hE<gt>\n"
"#include E<lt>limits.hE<gt>\n"
"#include E<lt>poll.hE<gt>\n"
"#include E<lt>stdio.hE<gt>\n"
"#include E<lt>stdlib.hE<gt>\n"
"#include E<lt>sys/fanotify.hE<gt>\n"
"#include E<lt>unistd.hE<gt>\n"

#. type: Plain text
#: build/C/man7/fanotify.7:554
#, no-wrap
msgid "/* Read all available fanotify events from the file descriptor 'fd' */\n"
msgstr "/* Read all available fanotify events from the file descriptor 'fd' */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:565
#, no-wrap
msgid ""
"static void\n"
"handle_events(int fd)\n"
"{\n"
"    const struct fanotify_event_metadata *metadata;\n"
"    struct fanotify_event_metadata buf[200];\n"
"    ssize_t len;\n"
"    char path[PATH_MAX];\n"
"    ssize_t path_len;\n"
"    char procfd_path[PATH_MAX];\n"
"    struct fanotify_response response;\n"
msgstr ""
"static void\n"
"handle_events(int fd)\n"
"{\n"
"    const struct fanotify_event_metadata *metadata;\n"
"    struct fanotify_event_metadata buf[200];\n"
"    ssize_t len;\n"
"    char path[PATH_MAX];\n"
"    ssize_t path_len;\n"
"    char procfd_path[PATH_MAX];\n"
"    struct fanotify_response response;\n"

#. type: Plain text
#: build/C/man7/fanotify.7:567
#, no-wrap
msgid "    /* Loop while events can be read from fanotify file descriptor */\n"
msgstr "    /* Loop while events can be read from fanotify file descriptor */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:569
#, no-wrap
msgid "    for(;;) {\n"
msgstr "    for(;;) {\n"

#. type: Plain text
#: build/C/man7/fanotify.7:571
#, no-wrap
msgid "        /* Read some events */\n"
msgstr "        /* Read some events */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:577
#, no-wrap
msgid ""
"        len = read(fd, (void *) &buf, sizeof(buf));\n"
"        if (len == -1 && errno != EAGAIN) {\n"
"            perror(\"read\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"
msgstr ""
"        len = read(fd, (void *) &buf, sizeof(buf));\n"
"        if (len == -1 && errno != EAGAIN) {\n"
"            perror(\"read\");\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:579
#, no-wrap
msgid "        /* Check if end of available data reached */\n"
msgstr "        /* Check if end of available data reached */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:584
#, no-wrap
msgid "        /* Point to the first event in the buffer */\n"
msgstr "        /* Point to the first event in the buffer */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:586
#, no-wrap
msgid "        metadata = buf;\n"
msgstr "        metadata = buf;\n"

#. type: Plain text
#: build/C/man7/fanotify.7:590
#, no-wrap
msgid "        while (FAN_EVENT_OK(metadata, len)) {\n"
msgstr "        while (FAN_EVENT_OK(metadata, len)) {\n"

#. type: Plain text
#: build/C/man7/fanotify.7:592
#, no-wrap
msgid "            /* Check that run-time and compile-time structures match */\n"
msgstr "            /* Check that run-time and compile-time structures match */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:598
#, no-wrap
msgid ""
"            if (metadata-E<gt>vers != FANOTIFY_METADATA_VERSION) {\n"
"                fprintf(stderr,\n"
"                        \"Mismatch of fanotify metadata version.\\en\");\n"
"                exit(EXIT_FAILURE);\n"
"            }\n"
msgstr ""
"            if (metadata-E<gt>vers != FANOTIFY_METADATA_VERSION) {\n"
"                fprintf(stderr,\n"
"                        \"Mismatch of fanotify metadata version.\\en\");\n"
"                exit(EXIT_FAILURE);\n"
"            }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:602
#, no-wrap
msgid ""
"            /* metadata-E<gt>fd contains either FAN_NOFD, indicating a\n"
"               queue overflow, or a file descriptor (a nonnegative\n"
"               integer). Here, we simply ignore queue overflow. */\n"
msgstr ""
"            /* metadata-E<gt>fd contains either FAN_NOFD, indicating a\n"
"               queue overflow, or a file descriptor (a nonnegative\n"
"               integer). Here, we simply ignore queue overflow. */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:604
#, no-wrap
msgid "            if (metadata-E<gt>fd E<gt>= 0) {\n"
msgstr "            if (metadata-E<gt>fd E<gt>= 0) {\n"

#. type: Plain text
#: build/C/man7/fanotify.7:606
#, no-wrap
msgid "                /* Handle open permission event */\n"
msgstr "                /* Handle open permission event */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:609
#, no-wrap
msgid ""
"                if (metadata-E<gt>mask & FAN_OPEN_PERM) {\n"
"                    printf(\"FAN_OPEN_PERM: \");\n"
msgstr ""
"                if (metadata-E<gt>mask & FAN_OPEN_PERM) {\n"
"                    printf(\"FAN_OPEN_PERM: \");\n"

#. type: Plain text
#: build/C/man7/fanotify.7:611
#, no-wrap
msgid "                    /* Allow file to be opened */\n"
msgstr "                    /* Allow file to be opened */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:617
#, no-wrap
msgid ""
"                    response.fd = metadata-E<gt>fd;\n"
"                    response.response = FAN_ALLOW;\n"
"                    write(fd, &response,\n"
"                          sizeof(struct fanotify_response));\n"
"                }\n"
msgstr ""
"                    response.fd = metadata-E<gt>fd;\n"
"                    response.response = FAN_ALLOW;\n"
"                    write(fd, &response,\n"
"                          sizeof(struct fanotify_response));\n"
"                }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:619
#, no-wrap
msgid "                /* Handle closing of writable file event */\n"
msgstr "                /* Handle closing of writable file event */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:622
#, no-wrap
msgid ""
"                if (metadata-E<gt>mask & FAN_CLOSE_WRITE)\n"
"                    printf(\"FAN_CLOSE_WRITE: \");\n"
msgstr ""
"                if (metadata-E<gt>mask & FAN_CLOSE_WRITE)\n"
"                    printf(\"FAN_CLOSE_WRITE: \");\n"

#. type: Plain text
#: build/C/man7/fanotify.7:624
#, no-wrap
msgid "                /* Retrieve and print pathname of the accessed file */\n"
msgstr "                /* Retrieve and print pathname of the accessed file */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:633
#, no-wrap
msgid ""
"                snprintf(procfd_path, sizeof(procfd_path),\n"
"                         \"/proc/self/fd/%d\", metadata-E<gt>fd);\n"
"                path_len = readlink(procfd_path, path,\n"
"                                    sizeof(path) - 1);\n"
"                if (path_len == -1) {\n"
"                    perror(\"readlink\");\n"
"                    exit(EXIT_FAILURE);\n"
"                }\n"
msgstr ""
"                snprintf(procfd_path, sizeof(procfd_path),\n"
"                         \"/proc/self/fd/%d\", metadata-E<gt>fd);\n"
"                path_len = readlink(procfd_path, path,\n"
"                                    sizeof(path) - 1);\n"
"                if (path_len == -1) {\n"
"                    perror(\"readlink\");\n"
"                    exit(EXIT_FAILURE);\n"
"                }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:636
#, no-wrap
msgid ""
"                path[path_len] = '\\e0';\n"
"                printf(\"File %s\\en\", path);\n"
msgstr ""
"                path[path_len] = '\\e0';\n"
"                printf(\"File %s\\en\", path);\n"

#. type: Plain text
#: build/C/man7/fanotify.7:638
#, no-wrap
msgid "                /* Close the file descriptor of the event */\n"
msgstr "                /* Close the file descriptor of the event */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:641
#, no-wrap
msgid ""
"                close(metadata-E<gt>fd);\n"
"            }\n"
msgstr ""
"                close(metadata-E<gt>fd);\n"
"            }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:643
#, no-wrap
msgid "            /* Advance to next event */\n"
msgstr "            /* Advance to next event */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:648
#, no-wrap
msgid ""
"            metadata = FAN_EVENT_NEXT(metadata, len);\n"
"        }\n"
"    }\n"
"}\n"
msgstr ""
"            metadata = FAN_EVENT_NEXT(metadata, len);\n"
"        }\n"
"    }\n"
"}\n"

#. type: Plain text
#: build/C/man7/fanotify.7:656
#, no-wrap
msgid ""
"int\n"
"main(int argc, char *argv[])\n"
"{\n"
"    char buf;\n"
"    int fd, poll_num;\n"
"    nfds_t nfds;\n"
"    struct pollfd fds[2];\n"
msgstr ""
"int\n"
"main(int argc, char *argv[])\n"
"{\n"
"    char buf;\n"
"    int fd, poll_num;\n"
"    nfds_t nfds;\n"
"    struct pollfd fds[2];\n"

#. type: Plain text
#: build/C/man7/fanotify.7:658
#, no-wrap
msgid "    /* Check mount point is supplied */\n"
msgstr "    /* Check mount point is supplied */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:663
#, no-wrap
msgid ""
"    if (argc != 2) {\n"
"        fprintf(stderr, \"Usage: %s MOUNT\\en\", argv[0]);\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"
msgstr ""
"    if (argc != 2) {\n"
"        fprintf(stderr, \"Usage: %s MOUNT\\en\", argv[0]);\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:665
#, no-wrap
msgid "    printf(\"Press enter key to terminate.\\en\");\n"
msgstr "    printf(\"Press enter key to terminate.\\en\");\n"

#. type: Plain text
#: build/C/man7/fanotify.7:667
#, no-wrap
msgid "    /* Create the file descriptor for accessing the fanotify API */\n"
msgstr "    /* Create the file descriptor for accessing the fanotify API */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:674
#, no-wrap
msgid ""
"    fd = fanotify_init(FAN_CLOEXEC | FAN_CLASS_CONTENT | FAN_NONBLOCK,\n"
"                       O_RDONLY | O_LARGEFILE);\n"
"    if (fd == -1) {\n"
"        perror(\"fanotify_init\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"
msgstr ""
"    fd = fanotify_init(FAN_CLOEXEC | FAN_CLASS_CONTENT | FAN_NONBLOCK,\n"
"                       O_RDONLY | O_LARGEFILE);\n"
"    if (fd == -1) {\n"
"        perror(\"fanotify_init\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:679
#, no-wrap
msgid ""
"    /* Mark the mount for:\n"
"       - permission events before opening files\n"
"       - notification events after closing a write-enabled\n"
"         file descriptor */\n"
msgstr ""
"    /* Mark the mount for:\n"
"       - permission events before opening files\n"
"       - notification events after closing a write-enabled\n"
"         file descriptor */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:686
#, no-wrap
msgid ""
"    if (fanotify_mark(fd, FAN_MARK_ADD | FAN_MARK_MOUNT,\n"
"                      FAN_OPEN_PERM | FAN_CLOSE_WRITE, -1,\n"
"                      argv[1]) == -1) {\n"
"        perror(\"fanotify_mark\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"
msgstr ""
"    if (fanotify_mark(fd, FAN_MARK_ADD | FAN_MARK_MOUNT,\n"
"                      FAN_OPEN_PERM | FAN_CLOSE_WRITE, -1,\n"
"                      argv[1]) == -1) {\n"
"        perror(\"fanotify_mark\");\n"
"        exit(EXIT_FAILURE);\n"
"    }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:697
#, no-wrap
msgid "    /* Fanotify input */\n"
msgstr "    /* Fanotify input */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:702
#, no-wrap
msgid "    /* This is the loop to wait for incoming events */\n"
msgstr "    /* This is the loop to wait for incoming events */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:704
#, no-wrap
msgid "    printf(\"Listening for events.\\en\");\n"
msgstr "    printf(\"Listening for events.\\en\");\n"

#. type: Plain text
#: build/C/man7/fanotify.7:710
#, no-wrap
msgid ""
"    while (1) {\n"
"        poll_num = poll(fds, nfds, -1);\n"
"        if (poll_num == -1) {\n"
"            if (errno == EINTR)     /* Interrupted by a signal */\n"
"                continue;           /* Restart poll() */\n"
msgstr ""
"    while (1) {\n"
"        poll_num = poll(fds, nfds, -1);\n"
"        if (poll_num == -1) {\n"
"            if (errno == EINTR)     /* Interrupted by a signal */\n"
"                continue;           /* Restart poll() */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:714
#, no-wrap
msgid ""
"            perror(\"poll\");         /* Unexpected error */\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"
msgstr ""
"            perror(\"poll\");         /* Unexpected error */\n"
"            exit(EXIT_FAILURE);\n"
"        }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:717
#, no-wrap
msgid ""
"        if (poll_num E<gt> 0) {\n"
"            if (fds[0].revents & POLLIN) {\n"
msgstr ""
"        if (poll_num E<gt> 0) {\n"
"            if (fds[0].revents & POLLIN) {\n"

#. type: Plain text
#: build/C/man7/fanotify.7:719
#, no-wrap
msgid "                /* Console input is available: empty stdin and quit */\n"
msgstr "                /* Console input is available: empty stdin and quit */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:728
#, no-wrap
msgid "                /* Fanotify events are available */\n"
msgstr "                /* Fanotify events are available */\n"

#. type: Plain text
#: build/C/man7/fanotify.7:733
#, no-wrap
msgid ""
"                handle_events(fd);\n"
"            }\n"
"        }\n"
"    }\n"
msgstr ""
"                handle_events(fd);\n"
"            }\n"
"        }\n"
"    }\n"

#. type: Plain text
#: build/C/man7/fanotify.7:737
#, no-wrap
msgid ""
"    printf(\"Listening for events stopped.\\en\");\n"
"    exit(EXIT_SUCCESS);\n"
"}\n"
msgstr ""
"    printf(\"Listening for events stopped.\\en\");\n"
"    exit(EXIT_SUCCESS);\n"
"}\n"

#. type: Plain text
#: build/C/man7/fanotify.7:743
msgid "B<fanotify_init>(2), B<fanotify_mark>(2), B<inotify>(7)"
msgstr "B<fanotify_init>(2), B<fanotify_mark>(2), B<inotify>(7)"