# Chinese simplified translation of util-linux.
# Copyright (C) 2008-2016, util-linux's authors.
# This file is distributed under the same license as the util-linux package.
# Ray Wang <wanglei1123@gmail.com>, 2008.
# Wylmer Wang <wantinghard@gmail.com>, 2012, 2013, 2014, 2015, 2016.
msgid ""
msgstr ""
"Project-Id-Version: util-linux-2.29-rc2\n"
"Report-Msgid-Bugs-To: util-linux@vger.kernel.org\n"
"POT-Creation-Date: 2018-03-21 13:12+0100\n"
"PO-Revision-Date: 2016-11-07 05:25-0500\n"
"Last-Translator: Wylmer Wang <wantinghard@gmail.com>\n"
"Language-Team: Chinese (simplified) <i18n-zh@googlegroups.com>\n"
"Language: zh_CN\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: crowdin.com\n"
"X-Crowdin-Project: util-linux\n"
"X-Crowdin-Language: zh-CN\n"
"X-Crowdin-File: util-linux-2.29-rc2.zh_CN.po\n"

#: disk-utils/addpart.c:15
#, c-format
msgid " %s <disk device> <partition number> <start> <length>\n"
msgstr " %s <磁盘设备> <分区号> <起点> <长度>\n"

#: disk-utils/addpart.c:19
msgid "Tell the kernel about the existence of a specified partition.\n"
msgstr "通知内核，存在某个指定分区。\n"

#: disk-utils/addpart.c:53 disk-utils/blockdev.c:244 disk-utils/delpart.c:53
#: disk-utils/mkfs.bfs.c:133 disk-utils/resizepart.c:95 misc-utils/kill.c:269
#: misc-utils/kill.c:311 misc-utils/rename.c:199 misc-utils/whereis.c:518
#: sys-utils/flock.c:175 sys-utils/ipcrm.c:160 sys-utils/ldattach.c:368
#: sys-utils/renice.c:146 sys-utils/switch_root.c:241 sys-utils/tunelp.c:152
#: term-utils/agetty.c:859 term-utils/agetty.c:860 term-utils/agetty.c:868
#: term-utils/agetty.c:869
msgid "not enough arguments"
msgstr "参数不够"

#: disk-utils/addpart.c:58 disk-utils/blockdev.c:295 disk-utils/blockdev.c:439
#: disk-utils/blockdev.c:465 disk-utils/cfdisk.c:2718 disk-utils/delpart.c:59
#: disk-utils/fdformat.c:229 disk-utils/fdisk.c:764 disk-utils/fdisk.c:1066
#: disk-utils/fdisk-list.c:321 disk-utils/fdisk-list.c:361
#: disk-utils/fdisk-list.c:380 disk-utils/fsck.c:1470
#: disk-utils/fsck.cramfs.c:152 disk-utils/fsck.cramfs.c:512
#: disk-utils/isosize.c:102 disk-utils/mkfs.bfs.c:192
#: disk-utils/mkfs.cramfs.c:171 disk-utils/mkfs.cramfs.c:660
#: disk-utils/mkfs.cramfs.c:800 disk-utils/mkfs.minix.c:824
#: disk-utils/mkswap.c:217 disk-utils/mkswap.c:246 disk-utils/partx.c:1013
#: disk-utils/resizepart.c:103 disk-utils/sfdisk.c:655 disk-utils/sfdisk.c:711
#: disk-utils/sfdisk.c:765 disk-utils/sfdisk.c:824 disk-utils/sfdisk.c:898
#: disk-utils/sfdisk.c:939 disk-utils/sfdisk.c:969 disk-utils/sfdisk.c:1006
#: disk-utils/sfdisk.c:1565 disk-utils/swaplabel.c:65 libfdisk/src/bsd.c:640
#: lib/path.c:95 lib/path.c:113 login-utils/islocal.c:87 login-utils/last.c:674
#: login-utils/sulogin.c:443 login-utils/sulogin.c:480
#: login-utils/utmpdump.c:134 login-utils/utmpdump.c:352
#: login-utils/utmpdump.c:374 login-utils/vipw.c:261 login-utils/vipw.c:279
#: misc-utils/findmnt.c:1099 misc-utils/logger.c:1223 misc-utils/mcookie.c:115
#: misc-utils/uuidd.c:198 sys-utils/blkdiscard.c:182 sys-utils/blkzone.c:96
#: sys-utils/dmesg.c:524 sys-utils/eject.c:499 sys-utils/eject.c:695
#: sys-utils/fallocate.c:396 sys-utils/fsfreeze.c:117 sys-utils/fstrim.c:74
#: sys-utils/hwclock.c:227 sys-utils/hwclock.c:814 sys-utils/hwclock-rtc.c:400
#: sys-utils/hwclock-rtc.c:435 sys-utils/ldattach.c:392 sys-utils/nsenter.c:129
#: sys-utils/rfkill.c:193 sys-utils/rfkill.c:544 sys-utils/rtcwake.c:136
#: sys-utils/rtcwake.c:286 sys-utils/setpriv.c:276 sys-utils/setpriv.c:614
#: sys-utils/setpriv.c:637 sys-utils/swapon.c:375 sys-utils/swapon.c:518
#: sys-utils/switch_root.c:167 sys-utils/unshare.c:108 sys-utils/unshare.c:123
#: sys-utils/wdctl.c:322 sys-utils/wdctl.c:378 sys-utils/zramctl.c:508
#: term-utils/agetty.c:2752 term-utils/mesg.c:127 term-utils/script.c:460
#: term-utils/script.c:468 term-utils/script.c:559
#: term-utils/scriptreplay.c:198 term-utils/scriptreplay.c:201
#: term-utils/wall.c:419 text-utils/colcrt.c:282 text-utils/more.c:534
#: text-utils/rev.c:141 text-utils/ul.c:230
#, c-format
msgid "cannot open %s"
msgstr "打不开 %s"

#: disk-utils/addpart.c:61 disk-utils/delpart.c:62 disk-utils/resizepart.c:100
msgid "invalid partition number argument"
msgstr "无效的分区号参数"

#: disk-utils/addpart.c:62
msgid "invalid start argument"
msgstr "无效的 起点 参数"

#: disk-utils/addpart.c:63 disk-utils/resizepart.c:110
msgid "invalid length argument"
msgstr "无效的长度参数"

#: disk-utils/addpart.c:64
msgid "failed to add partition"
msgstr "添加分区失败"

#: disk-utils/blockdev.c:63
msgid "set read-only"
msgstr "设置只读"

#: disk-utils/blockdev.c:70
msgid "set read-write"
msgstr "设置读写"

#: disk-utils/blockdev.c:76
msgid "get read-only"
msgstr "获得只读"

#: disk-utils/blockdev.c:82
msgid "get discard zeroes support status"
msgstr "获取 忽略零数据 支持状态"

#: disk-utils/blockdev.c:88
msgid "get logical block (sector) size"
msgstr "获得逻辑块(扇区)大小"

#: disk-utils/blockdev.c:94
msgid "get physical block (sector) size"
msgstr "获得物理块(扇区)大小"

#: disk-utils/blockdev.c:100
msgid "get minimum I/O size"
msgstr "获得最小 I/O 大小"

#: disk-utils/blockdev.c:106
msgid "get optimal I/O size"
msgstr "获得最优 I/O 大小"

#: disk-utils/blockdev.c:112
msgid "get alignment offset in bytes"
msgstr "获得对齐偏移字节数"

#: disk-utils/blockdev.c:118
msgid "get max sectors per request"
msgstr "获得每次请求的最大扇区数"

#: disk-utils/blockdev.c:124
msgid "get blocksize"
msgstr "获得块大小"

#: disk-utils/blockdev.c:131
msgid "set blocksize on file descriptor opening the block device"
msgstr "设置打开该块设备的文件描述符的块大小"

#: disk-utils/blockdev.c:137
msgid "get 32-bit sector count (deprecated, use --getsz)"
msgstr "获得 32-bit 扇区数量(已废弃，请使用 --getsz)"

#: disk-utils/blockdev.c:143
msgid "get size in bytes"
msgstr "获得字节大小"

#: disk-utils/blockdev.c:150
msgid "set readahead"
msgstr "设置 readahead"

#: disk-utils/blockdev.c:156
msgid "get readahead"
msgstr "获取 readahead"

#: disk-utils/blockdev.c:163
msgid "set filesystem readahead"
msgstr "设置 文件系统 readahead"

#: disk-utils/blockdev.c:169
msgid "get filesystem readahead"
msgstr "获取 文件系统 readahead"

#: disk-utils/blockdev.c:173
msgid "flush buffers"
msgstr "刷新缓存"

#: disk-utils/blockdev.c:177
msgid "reread partition table"
msgstr "重新读取分区表"

#: disk-utils/blockdev.c:187
#, c-format
msgid ""
" %1$s [-v|-q] commands devices\n"
" %1$s --report [devices]\n"
" %1$s -h|-V\n"
msgstr ""

#: disk-utils/blockdev.c:193
msgid "Call block device ioctls from the command line."
msgstr ""

#: disk-utils/blockdev.c:196
#, fuzzy
msgid " -q             quiet mode"
msgstr " -q, --quiet             开启安静模式\n"

#: disk-utils/blockdev.c:197
#, fuzzy
msgid " -v             verbose mode"
msgstr " -v, --verbose                 详尽模式\n"

#: disk-utils/blockdev.c:198
msgid "     --report   print report for specified (or all) devices"
msgstr ""

#: disk-utils/blockdev.c:203
#, fuzzy
msgid "Available commands:"
msgstr "可用的列：\n"

#: disk-utils/blockdev.c:204
#, c-format
msgid " %-25s get size in 512-byte sectors\n"
msgstr " %-25s 获得 512-字节扇区的大小\n"

#: disk-utils/blockdev.c:288 disk-utils/fdformat.c:219
#: disk-utils/fsck.minix.c:1341 disk-utils/isosize.c:205
#: disk-utils/mkfs.bfs.c:181 disk-utils/mkfs.c:116 disk-utils/mkfs.minix.c:813
#: disk-utils/swaplabel.c:181 misc-utils/wipefs.c:718
#: sys-utils/blkdiscard.c:171 sys-utils/blkzone.c:394 sys-utils/tunelp.c:242
#: sys-utils/zramctl.c:689 sys-utils/zramctl.c:715
msgid "no device specified"
msgstr "未指定设备"

#: disk-utils/blockdev.c:330
msgid "could not get device size"
msgstr "无法多得设备大小"

#: disk-utils/blockdev.c:336
#, c-format
msgid "Unknown command: %s"
msgstr "未知命令: %s"

#: disk-utils/blockdev.c:352
#, c-format
msgid "%s requires an argument"
msgstr "%s 需要一个参数"

#: disk-utils/blockdev.c:387 disk-utils/blockdev.c:493
#, c-format
msgid "ioctl error on %s"
msgstr "%s ioctl 出错"

#: disk-utils/blockdev.c:389
#, c-format
msgid "%s failed.\n"
msgstr "%s 失败.\n"

#: disk-utils/blockdev.c:396
#, c-format
msgid "%s succeeded.\n"
msgstr "%s 成功.\n"

#: disk-utils/blockdev.c:476
#, c-format
msgid "%s: failed to initialize sysfs handler"
msgstr "%s：初始化 sysfs 处理函数失败"

#: disk-utils/blockdev.c:480
#, c-format
msgid "%s: failed to read partition start from sysfs"
msgstr "%s：读取从 sysfs 起始的分区失败"

#: disk-utils/blockdev.c:501
#, c-format
msgid "RO    RA   SSZ   BSZ   StartSec            Size   Device\n"
msgstr "RO    RA   SSZ   BSZ   开始段              大小   设备\n"

#: disk-utils/cfdisk.c:186
msgid "Bootable"
msgstr "可启动"

#: disk-utils/cfdisk.c:186
msgid "Toggle bootable flag of the current partition"
msgstr "开关当前分区的 可启动 标志"

#: disk-utils/cfdisk.c:187
msgid "Delete"
msgstr "删除"

#: disk-utils/cfdisk.c:187
msgid "Delete the current partition"
msgstr "删除当前分区"

#: disk-utils/cfdisk.c:188
#, fuzzy
msgid "Resize"
msgstr "大小"

#: disk-utils/cfdisk.c:188
#, fuzzy
msgid "Reduce or enlarge the current partition"
msgstr "删除当前分区"

#: disk-utils/cfdisk.c:189
msgid "New"
msgstr "新建"

#: disk-utils/cfdisk.c:189
msgid "Create new partition from free space"
msgstr "在剩余空间上创建新分区"

#: disk-utils/cfdisk.c:190
msgid "Quit"
msgstr "退出"

#: disk-utils/cfdisk.c:190
msgid "Quit program without writing changes"
msgstr "退出程序而不写入更改"

#: disk-utils/cfdisk.c:191 libfdisk/src/bsd.c:438 libfdisk/src/bsd.c:1022
#: libfdisk/src/dos.c:2431 libfdisk/src/gpt.c:3132 libfdisk/src/sgi.c:1159
#: libfdisk/src/sun.c:1126
msgid "Type"
msgstr "类型"

#: disk-utils/cfdisk.c:191
msgid "Change the partition type"
msgstr "更改分区类型"

#: disk-utils/cfdisk.c:192
msgid "Help"
msgstr "帮助"

#: disk-utils/cfdisk.c:192
msgid "Print help screen"
msgstr "打印帮助界面"

#: disk-utils/cfdisk.c:193
msgid "Sort"
msgstr "排序"

#: disk-utils/cfdisk.c:193
msgid "Fix partitions order"
msgstr "修复分区顺序"

#: disk-utils/cfdisk.c:194
msgid "Write"
msgstr "写入"

#: disk-utils/cfdisk.c:194
msgid "Write partition table to disk (this might destroy data)"
msgstr "将分区表写入磁盘(可能损坏数据)"

#: disk-utils/cfdisk.c:195
msgid "Dump"
msgstr "转储"

#: disk-utils/cfdisk.c:195
msgid "Dump partition table to sfdisk compatible script file"
msgstr "将分区表转储到与 sfdisk 兼容的脚本文件"

#: disk-utils/cfdisk.c:642 disk-utils/fdisk.c:461
#, c-format
msgid "internal error: unsupported dialog type %d"
msgstr "内部错误：不支持的对话类型 %d"

#: disk-utils/cfdisk.c:1277
#, c-format
msgid "%s (mounted)"
msgstr "%s (已挂载)"

#: disk-utils/cfdisk.c:1297
msgid "Partition name:"
msgstr "分区名："

#: disk-utils/cfdisk.c:1304
msgid "Partition UUID:"
msgstr "分区 UUID："

#: disk-utils/cfdisk.c:1316
msgid "Partition type:"
msgstr "分区类型："

#: disk-utils/cfdisk.c:1323
msgid "Attributes:"
msgstr "属性："

#: disk-utils/cfdisk.c:1347
msgid "Filesystem UUID:"
msgstr "文件系统 UUID："

#: disk-utils/cfdisk.c:1354
msgid "Filesystem LABEL:"
msgstr "文件系统标签："

#: disk-utils/cfdisk.c:1360
msgid "Filesystem:"
msgstr "文件系统："

#: disk-utils/cfdisk.c:1365
msgid "Mountpoint:"
msgstr "挂载点："

#: disk-utils/cfdisk.c:1708
#, c-format
msgid "Disk: %s"
msgstr "磁盘：%s"

#: disk-utils/cfdisk.c:1710
#, c-format
msgid "Size: %s, %ju bytes, %ju sectors"
msgstr "尺寸：%s，%ju 字节，%ju 个扇区"

#: disk-utils/cfdisk.c:1713
#, c-format
msgid "Label: %s, identifier: %s"
msgstr "标签：%s，标识符：%s"

#: disk-utils/cfdisk.c:1716
#, c-format
msgid "Label: %s"
msgstr "标签：%s"

#: disk-utils/cfdisk.c:1866
msgid "May be followed by M for MiB, G for GiB, T for TiB, or S for sectors."
msgstr "后面可以加 M(MiB), G(GiB), T(TiB) 或 S(扇区)。"

#: disk-utils/cfdisk.c:1872
msgid "Please, specify size."
msgstr "请指定文件大小。"

#: disk-utils/cfdisk.c:1894
#, c-format
msgid "Minimum size is %ju bytes."
msgstr "最小尺寸为 %ju 字节。"

#: disk-utils/cfdisk.c:1903
#, c-format
msgid "Maximum size is %ju bytes."
msgstr "最大尺寸为 %ju 字节。"

#: disk-utils/cfdisk.c:1910
msgid "Failed to parse size."
msgstr "解析大小失败。"

#: disk-utils/cfdisk.c:1968
msgid "Select partition type"
msgstr "选择分区类型"

#: disk-utils/cfdisk.c:2018 disk-utils/cfdisk.c:2048
msgid "Enter script file name: "
msgstr "输入脚本文件名："

#: disk-utils/cfdisk.c:2019
msgid "The script file will be applied to in-memory partition table."
msgstr "该脚本文件将应用于内存中的分区表。"

#: disk-utils/cfdisk.c:2028 disk-utils/cfdisk.c:2070
#: disk-utils/fdisk-menu.c:480 disk-utils/fdisk-menu.c:524
#, c-format
msgid "Cannot open %s"
msgstr "打不开 %s"

#: disk-utils/cfdisk.c:2030 disk-utils/fdisk-menu.c:482
#, c-format
msgid "Failed to parse script file %s"
msgstr "解析脚本文件 %s 失败"

#: disk-utils/cfdisk.c:2032 disk-utils/fdisk-menu.c:484
#, c-format
msgid "Failed to apply script %s"
msgstr "应用脚本文件 %s 失败"

#: disk-utils/cfdisk.c:2049
msgid "The current in-memory partition table will be dumped to the file."
msgstr "当前的内存中分区表将转储到该文件中。"

#: disk-utils/cfdisk.c:2057 disk-utils/fdisk-menu.c:512
msgid "Failed to allocate script handler"
msgstr "分配脚本处理程序失败"

#: disk-utils/cfdisk.c:2063
msgid "Failed to read disk layout into script."
msgstr "将磁盘布局读入脚本出错。"

#: disk-utils/cfdisk.c:2077
msgid "Disk layout successfully dumped."
msgstr "成功转储了磁盘布局。"

#: disk-utils/cfdisk.c:2080 disk-utils/fdisk-menu.c:530
#, c-format
msgid "Failed to write script %s"
msgstr "写脚本文件 %s 失败"

#: disk-utils/cfdisk.c:2116
msgid "Select label type"
msgstr "选择标签类型"

#: disk-utils/cfdisk.c:2119 disk-utils/fdisk.c:1074 disk-utils/fdisk-menu.c:488
msgid "Device does not contain a recognized partition table."
msgstr "设备不包含可识别的分区表。"

#: disk-utils/cfdisk.c:2127
msgid "Select a type to create a new label or press 'L' to load script file."
msgstr "选择一种类型来创建新标签，或按“L”加载脚本文件。"

# 以下三句连贯，一起翻译
#: disk-utils/cfdisk.c:2176
msgid "This is cfdisk, a curses-based disk partitioning program."
msgstr "这是 cfdisk，一款基于 curses 的磁盘分区程序，"

#: disk-utils/cfdisk.c:2177
msgid "It lets you create, delete, and modify partitions on a block device."
msgstr "可以创建、删除和修改块设备上的分区。"

# 以下两条注意对齐
#: disk-utils/cfdisk.c:2179
msgid "Command      Meaning"
msgstr "命令         意义"

#: disk-utils/cfdisk.c:2180
msgid "-------      -------"
msgstr "-------      -------"

#: disk-utils/cfdisk.c:2181
msgid "  b          Toggle bootable flag of the current partition"
msgstr "  b          切换当前分区的 可启动 标志"

#: disk-utils/cfdisk.c:2182
msgid "  d          Delete the current partition"
msgstr "  d          删除当前分区"

#: disk-utils/cfdisk.c:2183
msgid "  h          Print this screen"
msgstr "  h          打印此屏幕"

#: disk-utils/cfdisk.c:2184
msgid "  n          Create new partition from free space"
msgstr "  n          从空闲空间创建新分区"

#: disk-utils/cfdisk.c:2185
msgid "  q          Quit program without writing partition table"
msgstr "  q          退出程序但不写入分区表"

#: disk-utils/cfdisk.c:2186
msgid "  s          Fix partitions order (only when in disarray)"
msgstr "  s          修复分区顺序(仅磁盘阵列)"

#: disk-utils/cfdisk.c:2187
msgid "  t          Change the partition type"
msgstr "  t          更改分区类型"

#: disk-utils/cfdisk.c:2188
msgid "  u          Dump disk layout to sfdisk compatible script file"
msgstr "  u          将磁盘布局转储到兼容 sfdisk 的脚本文件"

#: disk-utils/cfdisk.c:2189
msgid "  W          Write partition table to disk (you must enter uppercase W);"
msgstr "  W          将分区表写入磁盘(必须输入大写 W)；"

#: disk-utils/cfdisk.c:2190
msgid "               since this might destroy data on the disk, you must either"
msgstr "             由于这可能破坏磁盘上的数据，您必须"

#: disk-utils/cfdisk.c:2191
msgid "               confirm or deny the write by entering 'yes' or 'no'"
msgstr "             通过输入“yes”或“no”来确认或拒绝"

#: disk-utils/cfdisk.c:2192
msgid "  x          Display/hide extra information about a partition"
msgstr "  x          显示/隐藏分区的额外信息"

#: disk-utils/cfdisk.c:2193
msgid "Up Arrow     Move cursor to the previous partition"
msgstr "上箭头       光标移到上一分区"

#: disk-utils/cfdisk.c:2194
msgid "Down Arrow   Move cursor to the next partition"
msgstr "下箭头       光标移到下一分区"

#: disk-utils/cfdisk.c:2195
msgid "Left Arrow   Move cursor to the previous menu item"
msgstr "上箭头       光标移到上一菜单项"

#: disk-utils/cfdisk.c:2196
msgid "Right Arrow  Move cursor to the next menu item"
msgstr "下箭头       光标移到下一菜单项"

#: disk-utils/cfdisk.c:2198
msgid "Note: All of the commands can be entered with either upper or lower"
msgstr "注：所有命令均可以大写或小写"

#: disk-utils/cfdisk.c:2199
msgid "case letters (except for Write)."
msgstr "字母输入(除了 写入)。"

#: disk-utils/cfdisk.c:2201
msgid "Use lsblk(8) or partx(8) to see more details about the device."
msgstr "使用 lsblk(8) 或 partx(8) 了解有关磁盘的更多细节。"

#: disk-utils/cfdisk.c:2211 disk-utils/cfdisk.c:2514
msgid "Press a key to continue."
msgstr "按下一个键继续。"

#: disk-utils/cfdisk.c:2297
msgid "Could not toggle the flag."
msgstr "无法切换标志。"

#: disk-utils/cfdisk.c:2307
#, c-format
msgid "Could not delete partition %zu."
msgstr "无法删除分区 %zu。"

#: disk-utils/cfdisk.c:2309 disk-utils/fdisk-menu.c:658
#, c-format
msgid "Partition %zu has been deleted."
msgstr "分区 %zu 已删除。"

#: disk-utils/cfdisk.c:2330
msgid "Partition size: "
msgstr "分区大小："

#: disk-utils/cfdisk.c:2371
#, c-format
msgid "Changed type of partition %zu."
msgstr "已更改分区 %zu 的类型。"

#: disk-utils/cfdisk.c:2373
#, c-format
msgid "The type of partition %zu is unchanged."
msgstr "分区 %zu 的类型未更改。"

#: disk-utils/cfdisk.c:2394
#, fuzzy
msgid "New size: "
msgstr "新 shell"

#: disk-utils/cfdisk.c:2409
#, fuzzy, c-format
msgid "Partition %zu resized."
msgstr "%s：已调整分区 #%d 的大小\n"

#: disk-utils/cfdisk.c:2427 disk-utils/cfdisk.c:2543 disk-utils/fdisk.c:1063
#: disk-utils/fdisk-menu.c:591
msgid "Device is open in read-only mode."
msgstr "设备以只读方式打开。"

#: disk-utils/cfdisk.c:2432
msgid "Are you sure you want to write the partition table to disk? "
msgstr "您确定想将分区表写入磁盘吗？"

#: disk-utils/cfdisk.c:2434
msgid "Type \"yes\" or \"no\", or press ESC to leave this dialog."
msgstr "输入“yes”或“no”或按 ESC 取消对话框。"

#: disk-utils/cfdisk.c:2439 login-utils/lslogins.c:209 sys-utils/lscpu.c:1436
#: sys-utils/lscpu.c:1446 sys-utils/lsmem.c:268
msgid "yes"
msgstr "是"

#: disk-utils/cfdisk.c:2440
msgid "Did not write partition table to disk."
msgstr "未将分区表写入磁盘。"

#: disk-utils/cfdisk.c:2445
msgid "Failed to write disklabel."
msgstr "写磁盘标签失败。"

#: disk-utils/cfdisk.c:2451 disk-utils/fdisk-menu.c:599
msgid "The partition table has been altered."
msgstr "分区表已调整。"

#: disk-utils/cfdisk.c:2474 disk-utils/cfdisk.c:2545
msgid "Note that partition table entries are not in disk order now."
msgstr "注意，现在分区表记录没有按磁盘顺序。"

#: disk-utils/cfdisk.c:2511
#, c-format
msgid "Device already contains a %s signature; it will be removed by a write command."
msgstr "设备已包含一个 %s 签名；写入命令会将其移除。"

#: disk-utils/cfdisk.c:2522
msgid "failed to create a new disklabel"
msgstr "创建新磁盘标签失败"

#: disk-utils/cfdisk.c:2530
msgid "failed to read partitions"
msgstr "读分区失败"

#: disk-utils/cfdisk.c:2629
#, c-format
msgid " %1$s [options] <disk>\n"
msgstr " %1$s [选项] <磁盘>\n"

#: disk-utils/cfdisk.c:2632 disk-utils/fdisk.c:808 disk-utils/sfdisk.c:1843
msgid "Display or manipulate a disk partition table.\n"
msgstr "显示或操作磁盘分区表。\n"

#: disk-utils/cfdisk.c:2635
msgid " -L, --color[=<when>]     colorize output (auto, always or never)\n"
msgstr " -L, --color[=<何时>]     彩色输出(auto自动，always总是或never从不)\n"

#: disk-utils/cfdisk.c:2638
msgid " -z, --zero               start with zeroed partition table\n"
msgstr " -z, --zero              以空分区表开始\n"

#: disk-utils/cfdisk.c:2676 disk-utils/fdisk.c:950 disk-utils/sfdisk.c:2120
#: misc-utils/cal.c:429 sys-utils/dmesg.c:1410 text-utils/hexdump.c:114
msgid "unsupported color mode"
msgstr "不支持的颜色模式"

#: disk-utils/cfdisk.c:2696 disk-utils/fdisk.c:888 disk-utils/sfdisk.c:224
msgid "failed to allocate libfdisk context"
msgstr "分配 libfdisk 环境(context)失败"

#: disk-utils/delpart.c:15
#, c-format
msgid " %s <disk device> <partition number>\n"
msgstr " %s <磁盘设备> <分区号>\n"

#: disk-utils/delpart.c:19
msgid "Tell the kernel to forget about a specified partition.\n"
msgstr "通知内核忘记某个特定的分区。\n"

#: disk-utils/delpart.c:63
msgid "failed to remove partition"
msgstr "移除分区失败"

#: disk-utils/fdformat.c:53
#, c-format
msgid "Formatting ... "
msgstr "正在格式化 ... "

#: disk-utils/fdformat.c:68 disk-utils/fdformat.c:138
#, c-format
msgid "done\n"
msgstr "完成\n"

#: disk-utils/fdformat.c:80
#, c-format
msgid "Verifying ... "
msgstr "正在验证 ... "

#: disk-utils/fdformat.c:108
msgid "Read: "
msgstr "读: "

#: disk-utils/fdformat.c:110
#, c-format
msgid "Problem reading track/head %u/%u, expected %d, read %d\n"
msgstr "读磁道/磁头 %u/%u 时出问题, 期望 %d, 读取 %d\n"

#: disk-utils/fdformat.c:127
#, c-format
msgid ""
"bad data in track/head %u/%u\n"
"Continuing ... "
msgstr ""
"磁道/磁头 %u/%u 有坏数据\n"
"将继续 ... "

#: disk-utils/fdformat.c:145 disk-utils/fsck.minix.c:183
#: disk-utils/swaplabel.c:123 misc-utils/wipefs.c:602 sys-utils/blkdiscard.c:85
#: sys-utils/tunelp.c:95
#, c-format
msgid " %s [options] <device>\n"
msgstr " %s [选项] <设备>\n"

#: disk-utils/fdformat.c:149
msgid "Do a low-level formatting of a floppy disk.\n"
msgstr "对软盘进行低级格式化。\n"

#: disk-utils/fdformat.c:152
msgid " -f, --from <N>    start at the track N (default 0)\n"
msgstr " -f, --from <N>    从磁道 N 开始(默认 0)\n"

#: disk-utils/fdformat.c:153
msgid " -t, --to <N>      stop at the track N\n"
msgstr " -t, --to <N>      在磁道 N 停止\n"

#: disk-utils/fdformat.c:154
msgid ""
" -r, --repair <N>  try to repair tracks failed during\n"
"                     the verification (max N retries)\n"
msgstr ""
" -r, --repair <N>  尝试修复在验证时失败的磁道\n"
"                     (最多尝试 N 次)\n"

#: disk-utils/fdformat.c:156
msgid " -n, --no-verify   disable the verification after the format\n"
msgstr " -n, --no-verify   禁止格式化后的验证\n"

#: disk-utils/fdformat.c:194
msgid "invalid argument - from"
msgstr "无效参数 - from"

#: disk-utils/fdformat.c:198
msgid "invalid argument - to"
msgstr "无效参数 - to"

#: disk-utils/fdformat.c:201
msgid "invalid argument - repair"
msgstr "无效参数 - repair"

#: disk-utils/fdformat.c:223 disk-utils/fsck.cramfs.c:148
#: disk-utils/mkfs.bfs.c:188 disk-utils/mkfs.cramfs.c:337
#: disk-utils/mkfs.cramfs.c:758 disk-utils/mkfs.cramfs.c:797
#: disk-utils/mkfs.minix.c:821 disk-utils/mkswap.c:243 disk-utils/partx.c:951
#: login-utils/last.c:688 login-utils/utmpdump.c:137 misc-utils/namei.c:135
#: misc-utils/rename.c:63 sys-utils/blkdiscard.c:185 sys-utils/blkzone.c:99
#: sys-utils/dmesg.c:526 sys-utils/fallocate.c:197 sys-utils/fsfreeze.c:120
#: sys-utils/fstrim.c:79 sys-utils/nsenter.c:164 sys-utils/nsenter.c:168
#: sys-utils/swapon.c:523 sys-utils/switch_root.c:94
#: sys-utils/switch_root.c:137 term-utils/mesg.c:129 text-utils/more.c:525
#, c-format
msgid "stat of %s failed"
msgstr "对 %s stat 失败"

#: disk-utils/fdformat.c:226 disk-utils/partx.c:1010 misc-utils/lsblk.c:1501
#: sys-utils/blkdiscard.c:187 sys-utils/blkzone.c:101
#: sys-utils/mountpoint.c:107
#, c-format
msgid "%s: not a block device"
msgstr "%s：不是一个块设备"

#: disk-utils/fdformat.c:231
msgid "could not determine current format type"
msgstr "不能确定当前格式类型"

#: disk-utils/fdformat.c:233
#, c-format
msgid "%s-sided, %d tracks, %d sec/track. Total capacity %d kB.\n"
msgstr "%s-面, %d 磁道, %d 秒/磁道. 总容量 %d kB.\n"

#: disk-utils/fdformat.c:234
msgid "Double"
msgstr "双面"

#: disk-utils/fdformat.c:234
msgid "Single"
msgstr "单面"

#: disk-utils/fdformat.c:241
msgid "user defined start track exceeds the medium specific maximum"
msgstr "用户定义的起始磁道超出了媒体的最大指定值"

#: disk-utils/fdformat.c:243
msgid "user defined end track exceeds the medium specific maximum"
msgstr "用户定义的结束磁道超出了媒体的最大指定值"

#: disk-utils/fdformat.c:245
msgid "user defined start track exceeds the user defined end track"
msgstr "用户定义的起始磁道超过了定义的终止磁道"

#: disk-utils/fdformat.c:253 misc-utils/logger.c:1022
msgid "close failed"
msgstr "关闭失败"

#: disk-utils/fdisk.c:204
#, c-format
msgid "Select (default %c): "
msgstr "选择 (默认 %c)："

#: disk-utils/fdisk.c:209
#, c-format
msgid "Using default response %c."
msgstr "将使用默认回应 %c。"

#: disk-utils/fdisk.c:222 disk-utils/fdisk.c:296 disk-utils/fdisk.c:371
#: libfdisk/src/dos.c:1241 libfdisk/src/gpt.c:2469
msgid "Value out of range."
msgstr "值超出范围。"

#: disk-utils/fdisk.c:251
#, c-format
msgid "%s (%s, default %c): "
msgstr "%s (%s，默认 %c)："

#: disk-utils/fdisk.c:254 disk-utils/fdisk.c:321
#, c-format
msgid "%s (%s, default %<PRIu64>): "
msgstr "%s (%s, 默认  %<PRIu64>): "

#: disk-utils/fdisk.c:259
#, c-format
msgid "%s (%c-%c, default %c): "
msgstr "%s (%c-%c，默认为 %c)："

#: disk-utils/fdisk.c:263 disk-utils/fdisk.c:325
#, c-format
msgid "%s (%<PRIu64>-%<PRIu64>, default %<PRIu64>): "
msgstr "%s (%<PRIu64>-%<PRIu64>, 默认 %<PRIu64>): "

#: disk-utils/fdisk.c:266
#, c-format
msgid "%s (%c-%c): "
msgstr "%s (%c-%c)："

#: disk-utils/fdisk.c:269 disk-utils/fdisk.c:328
#, c-format
msgid "%s (%<PRIu64>-%<PRIu64>): "
msgstr "%s (%<PRIu64>-%<PRIu64>): "

#: disk-utils/fdisk.c:438 disk-utils/sfdisk.c:198
msgid " [Y]es/[N]o: "
msgstr "是[Y]/否[N]："

#: disk-utils/fdisk.c:479
msgid "Hex code (type L to list all codes): "
msgstr "Hex 代码(输入 L 列出所有代码)："

#: disk-utils/fdisk.c:480
msgid "Partition type (type L to list all types): "
msgstr "分区类型(输入 L 列出所有类型)："

#: disk-utils/fdisk.c:582
msgid "DOS Compatibility flag is set (DEPRECATED!)"
msgstr "已设置 DOS 兼容性标志(已废弃！)"

#: disk-utils/fdisk.c:583
msgid "DOS Compatibility flag is not set"
msgstr "DOS 兼容性标志未设置"

#: disk-utils/fdisk.c:604 disk-utils/fdisk.c:640
#, c-format
msgid "Partition %zu does not exist yet!"
msgstr "分区 %zu 还不存在！"

#: disk-utils/fdisk.c:609 disk-utils/fdisk.c:618 libfdisk/src/ask.c:1003
msgid "Unknown"
msgstr "未知"

#: disk-utils/fdisk.c:617
#, c-format
msgid "Changed type of partition '%s' to '%s'."
msgstr "已将分区“%s”的类型更改为“%s”。"

#: disk-utils/fdisk.c:621
#, c-format
msgid "Type of partition %zu is unchanged: %s."
msgstr "分区 %zu 的类型未更改：%s。"

#: disk-utils/fdisk.c:660
#, c-format
msgid "%15s: %s"
msgstr "%15s: %s"

#: disk-utils/fdisk.c:717
#, c-format
msgid ""
"\n"
"%s: offset = %<PRIu64>, size = %zu bytes."
msgstr ""
"\n"
"%s: 偏移 = %<PRIu64>, 大小 = %zu 字节。"

#: disk-utils/fdisk.c:723
msgid "cannot seek"
msgstr "无法定位"

#: disk-utils/fdisk.c:728
msgid "cannot read"
msgstr "不能读"

#: disk-utils/fdisk.c:741 libfdisk/src/bsd.c:258 libfdisk/src/dos.c:982
#: libfdisk/src/gpt.c:2398
msgid "First sector"
msgstr "第一个扇区"

#: disk-utils/fdisk.c:768
#, c-format
msgid "BLKGETSIZE ioctl failed on %s"
msgstr "对 %s 进行 BLKGETSIZE ioctl 失败"

#: disk-utils/fdisk.c:786 disk-utils/sfdisk.c:1474
#, fuzzy, c-format
msgid "The old %s signature will be removed by a write command."
msgstr "写入命令将移除该签名。"

#: disk-utils/fdisk.c:790
#, fuzzy, c-format
msgid "The old %s signature may remain on the device. It is recommended to wipe the device with wipefs(8) or fdisk --wipe, in order to avoid possible collisions."
msgstr "强烈建议您使用 wipefs(8)来擦除该设备，以避免潜在的冲突。"

#: disk-utils/fdisk.c:803
#, c-format
msgid ""
" %1$s [options] <disk>      change partition table\n"
" %1$s [options] -l [<disk>] list partition table(s)\n"
msgstr ""
" %1$s [选项] <磁盘>         更改分区表\n"
" %1$s [选项] -l [<磁盘>]     列出分区表\n"

#: disk-utils/fdisk.c:811
msgid " -b, --sector-size <size>      physical and logical sector size\n"
msgstr " -b, --sectors-size <大小>     显示扇区计数和大小\n"

#: disk-utils/fdisk.c:812
msgid " -B, --protect-boot            don't erase bootbits when creating a new label\n"
msgstr " -B, --protect-boot            创建新标签时不要擦除 bootbits \n"

#: disk-utils/fdisk.c:813
msgid " -c, --compatibility[=<mode>]  mode is 'dos' or 'nondos' (default)\n"
msgstr " -c, --compatibility[=<模式>]  模式，为“dos”或“nondos”(默认)\n"

#: disk-utils/fdisk.c:814
msgid " -L, --color[=<when>]          colorize output (auto, always or never)\n"
msgstr " -L, --color[=<时机>]          彩色输出(auto, always 或 never)\n"

#: disk-utils/fdisk.c:817
msgid " -l, --list                    display partitions and exit\n"
msgstr " -l, --list                    显示分区并退出\n"

#: disk-utils/fdisk.c:818
msgid " -o, --output <list>           output columns\n"
msgstr " -o, --output <列表>           输出列\n"

#: disk-utils/fdisk.c:819
msgid " -t, --type <type>             recognize specified partition table type only\n"
msgstr " -t, --type <类型>             只识别指定的分区表类型\n"

#: disk-utils/fdisk.c:820
msgid " -u, --units[=<unit>]          display units: 'cylinders' or 'sectors' (default)\n"
msgstr " -u, --units[=<单位>]          显示单位，“cylinders”柱面或“sectors”扇区(默认)\n"

#: disk-utils/fdisk.c:821
msgid " -s, --getsz                   display device size in 512-byte sectors [DEPRECATED]\n"
msgstr " -s, --getsz                   以 512-字节扇区显示设备大小[已废弃]\n"

#: disk-utils/fdisk.c:822
msgid "     --bytes                   print SIZE in bytes rather than in human readable format\n"
msgstr "     -b, --bytes                   以字节为单位而非易读的格式来打印 SIZE\n"

#: disk-utils/fdisk.c:823
msgid " -w, --wipe <mode>             wipe signatures (auto, always or never)\n"
msgstr " -w, --wipe <模式>             擦除签名(auto, always 或 never)\n"

#: disk-utils/fdisk.c:824 disk-utils/sfdisk.c:1886
msgid " -W, --wipe-partitions <mode>  wipe signatures from new partitions (auto, always or never)\n"
msgstr " -W, --wipe-partitions <模式>  擦除新分区的签名(auto, always 或 never)\n"

#: disk-utils/fdisk.c:827
msgid " -C, --cylinders <number>      specify the number of cylinders\n"
msgstr " -C, --cylinders <数字>        指定柱面数\n"

#: disk-utils/fdisk.c:828
msgid " -H, --heads <number>          specify the number of heads\n"
msgstr " -H, --heads <数字>            指定磁头数\n"

#: disk-utils/fdisk.c:829
msgid " -S, --sectors <number>        specify the number of sectors per track\n"
msgstr " -S, --sectors <数字>          指定每条磁道的扇区数\n"

#: disk-utils/fdisk.c:898 disk-utils/fdisk.c:900 disk-utils/partx.c:873
msgid "invalid sector size argument"
msgstr "无效的 扇区大小 参数"

#: disk-utils/fdisk.c:910
msgid "invalid cylinders argument"
msgstr "无效的 柱面数 参数"

#: disk-utils/fdisk.c:922
msgid "not found DOS label driver"
msgstr "未找到 DOS 标签驱动"

#: disk-utils/fdisk.c:928
#, c-format
msgid "unknown compatibility mode '%s'"
msgstr "未知兼容模式“%s”"

#: disk-utils/fdisk.c:935
msgid "invalid heads argument"
msgstr "无效的 磁头数 参数"

#: disk-utils/fdisk.c:941
msgid "invalid sectors argument"
msgstr "无效的 扇区数 参数"

#: disk-utils/fdisk.c:967
#, c-format
msgid "unsupported disklabel: %s"
msgstr "不支持的磁盘标签：%s"

#: disk-utils/fdisk.c:975
#, fuzzy
msgid "unsupported unit"
msgstr "不支持的单位“%c”"

#: disk-utils/fdisk.c:984 disk-utils/fdisk.c:989 disk-utils/sfdisk.c:2084
#: disk-utils/sfdisk.c:2089
msgid "unsupported wipe mode"
msgstr "不支持的擦除模式"

#: disk-utils/fdisk.c:1002
msgid "The device properties (sector size and geometry) should be used with one specified device only."
msgstr "设备属性(扇区大小和几何属性)只能用于某个指定的设备。"

#: disk-utils/fdisk.c:1033 disk-utils/fdisk.c:1048 disk-utils/fsck.cramfs.c:695
#: disk-utils/mkfs.bfs.c:198 disk-utils/mkfs.cramfs.c:787
#: disk-utils/partx.c:967 disk-utils/raw.c:137 disk-utils/raw.c:150
#: disk-utils/raw.c:162 disk-utils/raw.c:203 misc-utils/cal.c:520
#: misc-utils/findfs.c:58 misc-utils/look.c:150 misc-utils/whereis.c:573
#: misc-utils/whereis.c:584 misc-utils/whereis.c:595 misc-utils/whereis.c:637
#: schedutils/chrt.c:504 schedutils/ionice.c:262 schedutils/taskset.c:189
#: sys-utils/chcpu.c:344 sys-utils/chmem.c:419 sys-utils/dmesg.c:1469
#: sys-utils/ipcmk.c:135 sys-utils/ldattach.c:321 sys-utils/losetup.c:888
#: sys-utils/lscpu.c:2025 sys-utils/lsmem.c:628 sys-utils/mount.c:698
#: sys-utils/mount.c:711 sys-utils/mount.c:780 sys-utils/mountpoint.c:181
#: sys-utils/pivot_root.c:72 sys-utils/swapoff.c:230 sys-utils/swapon.c:988
#: sys-utils/switch_root.c:250 sys-utils/umount.c:528 term-utils/setterm.c:1176
#: text-utils/col.c:233 text-utils/more.c:337
#, fuzzy
msgid "bad usage"
msgstr "错误值"

#: disk-utils/fdisk.c:1054
#, c-format
msgid "Welcome to fdisk (%s)."
msgstr "欢迎使用 fdisk (%s)。"

#: disk-utils/fdisk.c:1056 disk-utils/sfdisk.c:1616
msgid ""
"Changes will remain in memory only, until you decide to write them.\n"
"Be careful before using the write command.\n"
msgstr ""
"更改将停留在内存中，直到您决定将更改写入磁盘。\n"
"使用写入命令前请三思。\n"

#: disk-utils/fdisk.c:1079
msgid "A hybrid GPT was detected. You have to sync the hybrid MBR manually (expert command 'M')."
msgstr "检测到混合 GPT。您需要手动同步混合 MBR (用专家命令“M”)"

#: disk-utils/fdisk-list.c:43
#, c-format
msgid "Disklabel type: %s"
msgstr "磁盘标签类型：%s"

#: disk-utils/fdisk-list.c:47
#, c-format
msgid "Disk identifier: %s"
msgstr "磁盘标识符：%s"

#: disk-utils/fdisk-list.c:60
#, c-format
msgid "Disk %s: %s, %ju bytes, %ju sectors"
msgstr "Disk %s：%s，%ju 字节，%ju 个扇区"

#: disk-utils/fdisk-list.c:67
#, c-format
msgid "Geometry: %d heads, %llu sectors/track, %llu cylinders"
msgstr "几何属性：%d 个磁头, %llu 个扇区/磁道, %llu 个柱面"

#: disk-utils/fdisk-list.c:72 disk-utils/fdisk-list.c:293
#, c-format
msgid "Units: %s of %d * %ld = %ld bytes"
msgstr "单元：%s / %d * %ld = %ld 字节"

#: disk-utils/fdisk-list.c:78 disk-utils/fdisk-list.c:299
#, c-format
msgid "Sector size (logical/physical): %lu bytes / %lu bytes"
msgstr "扇区大小(逻辑/物理)：%lu 字节 / %lu 字节"

#: disk-utils/fdisk-list.c:81
#, c-format
msgid "I/O size (minimum/optimal): %lu bytes / %lu bytes"
msgstr "I/O 大小(最小/最佳)：%lu 字节 / %lu 字节"

#: disk-utils/fdisk-list.c:85
#, c-format
msgid "Alignment offset: %lu bytes"
msgstr "对齐偏移量：%lu 字节"

#: disk-utils/fdisk-list.c:116 disk-utils/fdisk-list.c:236
#: disk-utils/fsck.c:1255
msgid "failed to allocate iterator"
msgstr "分配迭代器失败"

#: disk-utils/fdisk-list.c:122 disk-utils/fdisk-list.c:242
#: disk-utils/partx.c:667 login-utils/lslogins.c:916 misc-utils/fincore.c:361
#: misc-utils/findmnt.c:1596 misc-utils/lsblk.c:1908 misc-utils/lslocks.c:449
#: misc-utils/uuidparse.c:252 misc-utils/wipefs.c:151 sys-utils/losetup.c:321
#: sys-utils/lscpu.c:1609 sys-utils/lscpu.c:1712 sys-utils/lsipc.c:338
#: sys-utils/prlimit.c:297 sys-utils/rfkill.c:457 sys-utils/swapon.c:284
#: sys-utils/wdctl.c:260 sys-utils/zramctl.c:487 text-utils/column.c:209
msgid "failed to allocate output table"
msgstr "分配输出表失败"

#: disk-utils/fdisk-list.c:163 disk-utils/fdisk-list.c:266
#: disk-utils/partx.c:581 login-utils/lslogins.c:974 misc-utils/fincore.c:123
#: misc-utils/findmnt.c:688 misc-utils/findmnt.c:706 misc-utils/lsblk.c:1176
#: misc-utils/lslocks.c:391 misc-utils/uuidparse.c:154 misc-utils/wipefs.c:210
#: sys-utils/losetup.c:340 sys-utils/losetup.c:369 sys-utils/lscpu.c:1635
#: sys-utils/lscpu.c:1663 sys-utils/lsipc.c:470 sys-utils/lsipc.c:545
#: sys-utils/lsipc.c:647 sys-utils/lsipc.c:739 sys-utils/lsipc.c:900
#: sys-utils/prlimit.c:229 sys-utils/rfkill.c:374 sys-utils/swapon.c:179
#: sys-utils/wdctl.c:214 sys-utils/zramctl.c:407 text-utils/column.c:453
msgid "failed to allocate output line"
msgstr "分配输出行失败"

#: disk-utils/fdisk-list.c:173 disk-utils/fdisk-list.c:273
#: disk-utils/partx.c:644 login-utils/lslogins.c:1072 misc-utils/fincore.c:159
#: misc-utils/findmnt.c:692 misc-utils/findmnt.c:711 misc-utils/lsblk.c:1167
#: misc-utils/lslocks.c:436 misc-utils/uuidparse.c:239 misc-utils/wipefs.c:250
#: sys-utils/losetup.c:301 sys-utils/lscpu.c:1643 sys-utils/lscpu.c:1674
#: sys-utils/lsipc.c:504 sys-utils/lsipc.c:629 sys-utils/prlimit.c:261
#: sys-utils/rfkill.c:402 sys-utils/swapon.c:227 sys-utils/wdctl.c:242
#: sys-utils/zramctl.c:472 text-utils/column.c:460
#, fuzzy
msgid "failed to add output data"
msgstr "向输出表添加数据出错"

#: disk-utils/fdisk-list.c:193
#, c-format
msgid "Partition %zu does not start on physical sector boundary."
msgstr "分区 %zu 未起始于物理扇区边界。"

#: disk-utils/fdisk-list.c:200
#, c-format
msgid "Filesystem/RAID signature on partition %zu will be wiped."
msgstr ""

#: disk-utils/fdisk-list.c:209
msgid "Partition table entries are not in disk order."
msgstr "分区表记录没有按磁盘顺序。"

#: disk-utils/fdisk-list.c:228 libfdisk/src/bsd.c:1017 libfdisk/src/dos.c:2425
#: libfdisk/src/gpt.c:3128 libfdisk/src/sgi.c:1153 libfdisk/src/sun.c:1120
msgid "Start"
msgstr "起点"

#: disk-utils/fdisk-list.c:228 libfdisk/src/bsd.c:1018 libfdisk/src/dos.c:2426
#: libfdisk/src/gpt.c:3129 libfdisk/src/sgi.c:1154 libfdisk/src/sun.c:1121
msgid "End"
msgstr "末尾"

#: disk-utils/fdisk-list.c:228 libfdisk/src/bsd.c:1019 libfdisk/src/dos.c:2427
#: libfdisk/src/gpt.c:3130 libfdisk/src/sgi.c:1155 libfdisk/src/sun.c:1122
msgid "Sectors"
msgstr "扇区"

#: disk-utils/fdisk-list.c:228 libfdisk/src/bsd.c:1021 libfdisk/src/dos.c:2429
#: libfdisk/src/gpt.c:3131 libfdisk/src/sgi.c:1157 libfdisk/src/sun.c:1124
msgid "Size"
msgstr "大小"

#: disk-utils/fdisk-list.c:287
#, c-format
msgid "Unpartitioned space %s: %s, %ju bytes, %ju sectors"
msgstr "未分区的空间 %s：%s，%ju 个字节，%ju 个扇区"

#: disk-utils/fdisk-list.c:473
#, c-format
msgid "%s unknown column: %s"
msgstr "%s 未知列: %s"

#: disk-utils/fdisk-menu.c:97
msgid "Generic"
msgstr "常规"

#: disk-utils/fdisk-menu.c:98
msgid "delete a partition"
msgstr "删除分区"

#: disk-utils/fdisk-menu.c:99
msgid "list free unpartitioned space"
msgstr "列出未分区的空闲区"

#: disk-utils/fdisk-menu.c:100
msgid "list known partition types"
msgstr "列出已知分区类型"

#: disk-utils/fdisk-menu.c:101
msgid "add a new partition"
msgstr "添加新分区"

#: disk-utils/fdisk-menu.c:102
msgid "print the partition table"
msgstr "打印分区表"

#: disk-utils/fdisk-menu.c:103
msgid "change a partition type"
msgstr "更改分区类型"

#: disk-utils/fdisk-menu.c:104
msgid "verify the partition table"
msgstr "检查分区表"

#: disk-utils/fdisk-menu.c:105
msgid "print information about a partition"
msgstr "打印某个分区的相关信息"

#: disk-utils/fdisk-menu.c:107
msgid "print the raw data of the first sector from the device"
msgstr "打印设备第1个扇区的原始数据"

#: disk-utils/fdisk-menu.c:108
msgid "print the raw data of the disklabel from the device"
msgstr "打印设备磁盘标签的原始数据"

#: disk-utils/fdisk-menu.c:109
msgid "fix partitions order"
msgstr "修复分区顺序"

#: disk-utils/fdisk-menu.c:111
msgid "Misc"
msgstr "杂项"

#: disk-utils/fdisk-menu.c:112
msgid "print this menu"
msgstr "打印此菜单"

#: disk-utils/fdisk-menu.c:113
msgid "change display/entry units"
msgstr "更改 显示/记录 单位"

#: disk-utils/fdisk-menu.c:114
msgid "extra functionality (experts only)"
msgstr "更多功能(仅限专业人员)"

#: disk-utils/fdisk-menu.c:116
msgid "Script"
msgstr "脚本"

#: disk-utils/fdisk-menu.c:117
msgid "load disk layout from sfdisk script file"
msgstr "从 sfdisk 脚本文件加载磁盘布局"

#: disk-utils/fdisk-menu.c:118
msgid "dump disk layout to sfdisk script file"
msgstr "将磁盘布局转储为 sfdisk 脚本文件"

#: disk-utils/fdisk-menu.c:120
msgid "Save & Exit"
msgstr "保存并退出"

#: disk-utils/fdisk-menu.c:121
msgid "write table to disk and exit"
msgstr "将分区表写入磁盘并退出"

#: disk-utils/fdisk-menu.c:122
msgid "write table to disk"
msgstr "将分区表写入磁盘"

#: disk-utils/fdisk-menu.c:123
msgid "quit without saving changes"
msgstr "退出而不保存更改"

#: disk-utils/fdisk-menu.c:124
msgid "return to main menu"
msgstr "返回主菜单"

#: disk-utils/fdisk-menu.c:126
msgid "return from BSD to DOS"
msgstr "从 BSD 回到 DOS"

#: disk-utils/fdisk-menu.c:137
msgid "Create a new label"
msgstr "新建空磁盘标签"

#: disk-utils/fdisk-menu.c:138
msgid "create a new empty GPT partition table"
msgstr "新建一份 GPT 分区表"

#: disk-utils/fdisk-menu.c:139
msgid "create a new empty SGI (IRIX) partition table"
msgstr "新建一份空 GPT (IRIX) 分区表"

#: disk-utils/fdisk-menu.c:140
msgid "create a new empty DOS partition table"
msgstr "新建一份的空 DOS 分区表"

#: disk-utils/fdisk-menu.c:141
msgid "create a new empty Sun partition table"
msgstr "新建一份空 Sun 分区表"

#: disk-utils/fdisk-menu.c:145
msgid "create an IRIX (SGI) partition table"
msgstr "创建一份 IRIX(SGI) 分区表"

#: disk-utils/fdisk-menu.c:154
msgid "Geometry (for the current label)"
msgstr ""

#: disk-utils/fdisk-menu.c:155
msgid "change number of cylinders"
msgstr "更改柱面数"

#: disk-utils/fdisk-menu.c:156
msgid "change number of heads"
msgstr "更改磁头数"

#: disk-utils/fdisk-menu.c:157
msgid "change number of sectors/track"
msgstr "更改扇区/磁道数"

#: disk-utils/fdisk-menu.c:166 include/pt-mbr-partnames.h:95
msgid "GPT"
msgstr "GPT"

#: disk-utils/fdisk-menu.c:167
msgid "change disk GUID"
msgstr "更改磁盘 GUID"

#: disk-utils/fdisk-menu.c:168
msgid "change partition name"
msgstr "更改分区名"

#: disk-utils/fdisk-menu.c:169
msgid "change partition UUID"
msgstr "更改分区 UUID"

#: disk-utils/fdisk-menu.c:170
msgid "change table length"
msgstr "更改表长度"

#: disk-utils/fdisk-menu.c:171
msgid "enter protective/hybrid MBR"
msgstr "进入 保护/混合 MBR"

#: disk-utils/fdisk-menu.c:174
msgid "toggle the legacy BIOS bootable flag"
msgstr "开关旧 BIOS 的 可启动 标志"

#: disk-utils/fdisk-menu.c:175
msgid "toggle the no block IO protocol flag"
msgstr "开关 不阻塞 IO 协议 标志"

#: disk-utils/fdisk-menu.c:176
msgid "toggle the required partition flag"
msgstr "开关 必需分区 标志"

#: disk-utils/fdisk-menu.c:177
msgid "toggle the GUID specific bits"
msgstr "开/关 GUID 特定位"

#: disk-utils/fdisk-menu.c:187
msgid "Sun"
msgstr "Sun"

#: disk-utils/fdisk-menu.c:188
msgid "toggle the read-only flag"
msgstr "开关 只读 标志"

#: disk-utils/fdisk-menu.c:189
msgid "toggle the mountable flag"
msgstr "开关 可挂臷 标志"

#: disk-utils/fdisk-menu.c:191
msgid "change number of alternate cylinders"
msgstr "更改备选柱面数"

#: disk-utils/fdisk-menu.c:192
msgid "change number of extra sectors per cylinder"
msgstr "更改每柱面的额外扇区数"

#: disk-utils/fdisk-menu.c:193
msgid "change interleave factor"
msgstr "更改交错系数"

#: disk-utils/fdisk-menu.c:194
msgid "change rotation speed (rpm)"
msgstr "更改转速(转/分)"

#: disk-utils/fdisk-menu.c:195
msgid "change number of physical cylinders"
msgstr "更改物理柱面数"

#: disk-utils/fdisk-menu.c:204
msgid "SGI"
msgstr "SGI"

#: disk-utils/fdisk-menu.c:205
msgid "select bootable partition"
msgstr "选择可启动分区"

#: disk-utils/fdisk-menu.c:206
msgid "edit bootfile entry"
msgstr "编辑启动文件记录"

#: disk-utils/fdisk-menu.c:207
msgid "select sgi swap partition"
msgstr "选择 sgi 交换分区"

#: disk-utils/fdisk-menu.c:208
msgid "create SGI info"
msgstr "创建 SGI 信息"

#: disk-utils/fdisk-menu.c:217
msgid "DOS (MBR)"
msgstr "DOS (MBR)"

#: disk-utils/fdisk-menu.c:218
msgid "toggle a bootable flag"
msgstr "开关 可启动 标志"

#: disk-utils/fdisk-menu.c:219
msgid "edit nested BSD disklabel"
msgstr "编辑嵌套的 BSD 磁盘标签"

#: disk-utils/fdisk-menu.c:220
msgid "toggle the dos compatibility flag"
msgstr "开关 dos 兼容性标志"

#: disk-utils/fdisk-menu.c:222
msgid "move beginning of data in a partition"
msgstr "移动分区数据的起始点"

#: disk-utils/fdisk-menu.c:223
msgid "change the disk identifier"
msgstr "更改磁盘标识符"

#: disk-utils/fdisk-menu.c:225
msgid "return from protective/hybrid MBR to GPT"
msgstr "从 保护/混合 MBR 回到 GPT"

#: disk-utils/fdisk-menu.c:235
msgid "BSD"
msgstr "BSD"

#: disk-utils/fdisk-menu.c:236
msgid "edit drive data"
msgstr "编辑驱动数据"

#: disk-utils/fdisk-menu.c:237
msgid "install bootstrap"
msgstr "安装引导程序"

#: disk-utils/fdisk-menu.c:238
msgid "show complete disklabel"
msgstr "显示完整磁盘标签"

#: disk-utils/fdisk-menu.c:239
msgid "link BSD partition to non-BSD partition"
msgstr "将 BSD 分区链接到非 BSD 分区"

#: disk-utils/fdisk-menu.c:371
#, c-format
msgid ""
"\n"
"Help (expert commands):\n"
msgstr ""
"\n"
"帮助 (专业命令)：\n"

#: disk-utils/fdisk-menu.c:373 disk-utils/sfdisk.c:1283
#, c-format
msgid ""
"\n"
"Help:\n"
msgstr ""
"\n"
"帮助：\n"

#: disk-utils/fdisk-menu.c:393
#, c-format
msgid "You're editing nested '%s' partition table, primary partition table is '%s'."
msgstr "您正在编辑嵌套的“%s”分区表，主分区表为“%s”。"

#: disk-utils/fdisk-menu.c:423
msgid "Expert command (m for help): "
msgstr "专家命令(输入 m 显示帮助)："

#: disk-utils/fdisk-menu.c:425
msgid "Command (m for help): "
msgstr "命令(输入 m 获取帮助)："

#: disk-utils/fdisk-menu.c:435
msgid ""
"\n"
"Do you really want to quit? "
msgstr ""
"\n"
"您确实要退出吗？"

#: disk-utils/fdisk-menu.c:448
#, c-format
msgid "%c: unknown command"
msgstr "%c：未知命令"

#: disk-utils/fdisk-menu.c:473 disk-utils/fdisk-menu.c:506
msgid "Enter script file name"
msgstr "输入脚本文件名"

#: disk-utils/fdisk-menu.c:485
msgid "Resetting fdisk!"
msgstr ""

#: disk-utils/fdisk-menu.c:492
msgid "Script successfully applied."
msgstr "成功应用了脚本。"

#: disk-utils/fdisk-menu.c:518
msgid "Failed to transform disk layout into script"
msgstr "将磁盘布局转换成脚本失败"

#: disk-utils/fdisk-menu.c:532
msgid "Script successfully saved."
msgstr "成本保存了脚本。"

#: disk-utils/fdisk-menu.c:555 disk-utils/sfdisk.c:1504
#, c-format
msgid "Partition #%zu contains a %s signature."
msgstr "分区 #%zu 包含一个 %s 签名。"

#: disk-utils/fdisk-menu.c:558 disk-utils/sfdisk.c:1507
msgid "Do you want to remove the signature?"
msgstr "您想移除该签名吗？"

#: disk-utils/fdisk-menu.c:563 disk-utils/sfdisk.c:1512
msgid "The signature will be removed by a write command."
msgstr "写入命令将移除该签名。"

#: disk-utils/fdisk-menu.c:596
msgid "failed to write disklabel"
msgstr "写磁盘标签失败"

#: disk-utils/fdisk-menu.c:638
msgid "Failed to fix partitions order."
msgstr "修复分区顺序失败。"

#: disk-utils/fdisk-menu.c:640
msgid "Partitions order fixed."
msgstr "已修复分区顺序。"

#: disk-utils/fdisk-menu.c:656
#, c-format
msgid "Could not delete partition %zu"
msgstr "无法删除分区 %zu"

#: disk-utils/fdisk-menu.c:685
msgid "Changing display/entry units to cylinders (DEPRECATED!)."
msgstr "将显示/记录单位更改为柱面(已废弃！)。"

#: disk-utils/fdisk-menu.c:687
msgid "Changing display/entry units to sectors."
msgstr "将显示/记录单位更改为盲区。"

#: disk-utils/fdisk-menu.c:697 disk-utils/fdisk-menu.c:868
msgid "Leaving nested disklabel."
msgstr "离开嵌套的磁盘标签。"

#: disk-utils/fdisk-menu.c:734
msgid "New maximum entries"
msgstr "新的最大记录数"

#: disk-utils/fdisk-menu.c:745
msgid "Entering protective/hybrid MBR disklabel."
msgstr "进入 保护/混合 MBR 磁盘标签。"

#: disk-utils/fdisk-menu.c:761
msgid "New UUID (in 8-4-4-4-12 format)"
msgstr "新 UUID (以 8-4-4-4-12 格式)"

#: disk-utils/fdisk-menu.c:776
msgid "New name"
msgstr "新名称"

#: disk-utils/fdisk-menu.c:839
msgid "Entering nested BSD disklabel."
msgstr "进入嵌套的 BSD 磁盘标签。"

#: disk-utils/fdisk-menu.c:1037
msgid "Number of cylinders"
msgstr "柱面数"

#: disk-utils/fdisk-menu.c:1044
msgid "Number of heads"
msgstr "磁头数"

#: disk-utils/fdisk-menu.c:1050
msgid "Number of sectors"
msgstr "扇区数"

#: disk-utils/fsck.c:213
#, c-format
msgid "%s is mounted\n"
msgstr "%s 已经挂载\n"

#: disk-utils/fsck.c:215
#, c-format
msgid "%s is not mounted\n"
msgstr "%s 未挂载\n"

#: disk-utils/fsck.c:329 disk-utils/fsck.cramfs.c:171
#: disk-utils/fsck.cramfs.c:178 disk-utils/fsck.cramfs.c:234
#: disk-utils/fsck.cramfs.c:255 disk-utils/sfdisk.c:298 libfdisk/src/bsd.c:645
#: lib/path.c:140 lib/path.c:161 lib/path.c:182 lib/path.c:230
#: login-utils/last.c:208 login-utils/last.c:245 login-utils/sulogin.c:655
#: sys-utils/rfkill.c:214 sys-utils/setpriv.c:285 term-utils/setterm.c:723
#: term-utils/setterm.c:780 term-utils/setterm.c:784 term-utils/setterm.c:791
#, c-format
msgid "cannot read %s"
msgstr "不能读 %s"

#: disk-utils/fsck.c:331 lib/path.c:163 lib/path.c:184
#, c-format
msgid "parse error: %s"
msgstr "解析错误：%s"

#: disk-utils/fsck.c:358
#, c-format
msgid "cannot create directory %s"
msgstr "无法创建 %s 目录"

#: disk-utils/fsck.c:371
#, c-format
msgid "Locking disk by %s ... "
msgstr "正由 %s 锁定磁盘..."

#: disk-utils/fsck.c:382
#, c-format
msgid "(waiting) "
msgstr "(等待中) "

#. TRANSLATORS: These are followups to "Locking disk...".
#: disk-utils/fsck.c:392
msgid "succeeded"
msgstr "成功"

#: disk-utils/fsck.c:392
msgid "failed"
msgstr "失败"

#: disk-utils/fsck.c:410
#, c-format
msgid "Unlocking %s.\n"
msgstr "正在解锁 %s。\n"

#: disk-utils/fsck.c:442
#, c-format
msgid "failed to setup description for %s"
msgstr "设置 %s 描述 失败"

#: disk-utils/fsck.c:472 misc-utils/findmnt.c:784 misc-utils/lsblk.c:446
#: sys-utils/mount.c:101 sys-utils/swapon-common.c:19 sys-utils/umount.c:49
#, c-format
msgid "%s: parse error at line %d -- ignored"
msgstr "%s：第 %d 行解析出错 -- 已忽略"

#: disk-utils/fsck.c:504 disk-utils/fsck.c:506
#, c-format
msgid "%s: failed to parse fstab"
msgstr "%s：解析 fstab 失败"

#: disk-utils/fsck.c:687 login-utils/login.c:940 login-utils/sulogin.c:1024
#: login-utils/vipw.c:208 sys-utils/flock.c:346 sys-utils/nsenter.c:180
#: sys-utils/swapon.c:320 sys-utils/unshare.c:221 sys-utils/unshare.c:435
#: term-utils/script.c:805
msgid "fork failed"
msgstr "fork 失败"

#: disk-utils/fsck.c:694
#, c-format
msgid "%s: execute failed"
msgstr "%s：执行失败"

#: disk-utils/fsck.c:782
msgid "wait: no more child process?!?"
msgstr "等待：没有剩余子进程了？！？"

#: disk-utils/fsck.c:785 sys-utils/flock.c:364 sys-utils/swapon.c:352
#: sys-utils/unshare.c:419 sys-utils/unshare.c:440
msgid "waitpid failed"
msgstr "waitpid 失败"

#: disk-utils/fsck.c:803
#, c-format
msgid "Warning... %s for device %s exited with signal %d."
msgstr "警告... 对设备 %2$s 的 %1$s 以信号 %3$d 退出。"

#: disk-utils/fsck.c:809
#, c-format
msgid "%s %s: status is %x, should never happen."
msgstr "%s %s：状态为 %x，这不应该发生。"

#: disk-utils/fsck.c:855
#, c-format
msgid "Finished with %s (exit status %d)\n"
msgstr "以 %s 结束(退出状态为 %d)\n"

#: disk-utils/fsck.c:936
#, c-format
msgid "error %d (%m) while executing fsck.%s for %s"
msgstr "对 %3$s 执行 fsck.%2$s 时出现错误 %1$d (%m)"

#: disk-utils/fsck.c:1002
msgid ""
"Either all or none of the filesystem types passed to -t must be prefixed\n"
"with 'no' or '!'."
msgstr "传递给 -t 选项的文件系统类型必须全部/全不以“no”或“!”为前缀。"

#: disk-utils/fsck.c:1118
#, c-format
msgid "%s: skipping bad line in /etc/fstab: bind mount with nonzero fsck pass number"
msgstr "%s：将跳过 /etc/fstab 中的错误行：fsck 通过次数非零的绑定式挂载"

#: disk-utils/fsck.c:1130
#, c-format
msgid "%s: skipping nonexistent device\n"
msgstr "%s：将跳过不存在的设备\n"

#: disk-utils/fsck.c:1135
#, c-format
msgid "%s: nonexistent device (\"nofail\" fstab option may be used to skip this device)\n"
msgstr "%s：设备不存在(可以使用fstab 选项“nofail”来跳过此设备)\n"

#: disk-utils/fsck.c:1152
#, c-format
msgid "%s: skipping unknown filesystem type\n"
msgstr "%s：跳过未知的文件系统类型\n"

#: disk-utils/fsck.c:1166
#, c-format
msgid "cannot check %s: fsck.%s not found"
msgstr "无法检查 %s：找不到 fsck.%s"

#: disk-utils/fsck.c:1270
msgid "Checking all file systems.\n"
msgstr "正在检查所有文件系统。\n"

# pass number 是fstab中定义的，不为0则每次检测
#: disk-utils/fsck.c:1361
#, c-format
msgid "--waiting-- (pass %d)\n"
msgstr "--等待中-- (第 %d 遍)\n"

#: disk-utils/fsck.c:1387
#, c-format
msgid " %s [options] -- [fs-options] [<filesystem> ...]\n"
msgstr " %s [选项] -- [文件系统选项] [<文件系统> ...]\n"

#: disk-utils/fsck.c:1391
msgid "Check and repair a Linux filesystem.\n"
msgstr "检查并修复 Linux 文件系统。\n"

#: disk-utils/fsck.c:1394
msgid " -A         check all filesystems\n"
msgstr " -A         检查所有文件系统\n"

#: disk-utils/fsck.c:1395
msgid " -C [<fd>]  display progress bar; file descriptor is for GUIs\n"
msgstr " -C [<fd>]  显示进度条；文件描述符 fd 用于图形用户界面\n"

#: disk-utils/fsck.c:1396
msgid " -l         lock the device to guarantee exclusive access\n"
msgstr " -l         锁定设备以确保独占访问\n"

#: disk-utils/fsck.c:1397
msgid " -M         do not check mounted filesystems\n"
msgstr " -M         不检查已挂臷的文件系统\n"

#: disk-utils/fsck.c:1398
msgid " -N         do not execute, just show what would be done\n"
msgstr " -N         不执行，只显示将执行的操作\n"

#: disk-utils/fsck.c:1399
msgid " -P         check filesystems in parallel, including root\n"
msgstr " -P         并行检查文件系统，包括 root\n"

#: disk-utils/fsck.c:1400
msgid " -R         skip root filesystem; useful only with '-A'\n"
msgstr " -R         跳过根文件系统；只在指定 '-A' 时有用\n"

#: disk-utils/fsck.c:1401
msgid ""
" -r [<fd>]  report statistics for each device checked;\n"
"            file descriptor is for GUIs\n"
msgstr ""
" -r [<fd>]  报告对每个已检查设备的统计；\n"
"            文件描述符用于 GUI\n"

#: disk-utils/fsck.c:1403
msgid " -s         serialize the checking operations\n"
msgstr " -s         串行化检查操作\n"

#: disk-utils/fsck.c:1404
msgid " -T         do not show the title on startup\n"
msgstr " -T         启动时不显示标题\n"

#: disk-utils/fsck.c:1405
msgid ""
" -t <type>  specify filesystem types to be checked;\n"
"            <type> is allowed to be a comma-separated list\n"
msgstr ""
" -t <类型>  指定要检查的文件系统类型；\n"
"             <类型> 可以是以英文逗号分隔的列表\n"

#: disk-utils/fsck.c:1407
msgid " -V         explain what is being done\n"
msgstr " -V         解释正在进行的操作\n"

#: disk-utils/fsck.c:1413
msgid "See the specific fsck.* commands for available fs-options."
msgstr "参见特定的 fsck.* 命令了解可用的文件系统选项。"

#: disk-utils/fsck.c:1460
msgid "too many devices"
msgstr "设备过多"

#: disk-utils/fsck.c:1472
msgid "Is /proc mounted?"
msgstr "/proc 挂载了吗？"

#: disk-utils/fsck.c:1480
#, c-format
msgid "must be root to scan for matching filesystems: %s"
msgstr "必须以 root 用户进行匹配文件系统扫描：%s"

#: disk-utils/fsck.c:1484
#, c-format
msgid "couldn't find matching filesystem: %s"
msgstr "找不到匹配的文件系统：%s"

#: disk-utils/fsck.c:1492 disk-utils/fsck.c:1589 misc-utils/kill.c:236
#: sys-utils/eject.c:278
msgid "too many arguments"
msgstr "参数过多"

#: disk-utils/fsck.c:1547 disk-utils/fsck.c:1550
msgid "invalid argument of -r"
msgstr "-r 的参数无效"

#: disk-utils/fsck.c:1562
#, fuzzy, c-format
msgid "option '%s' may be specified only once"
msgstr "--pid 选项只能指定一次"

#: disk-utils/fsck.c:1569 misc-utils/kill.c:282
#, c-format
msgid "option '%s' requires an argument"
msgstr "“%s”选项需要一个参数"

#: disk-utils/fsck.c:1600
#, c-format
msgid "invalid argument of -r: %d"
msgstr "-r 的参数无效：%d"

#: disk-utils/fsck.c:1643
msgid "the -l option can be used with one device only -- ignore"
msgstr "-l 选项只能用于一个设备 -- 忽略"

#: disk-utils/fsck.cramfs.c:111
#, c-format
msgid " %s [options] <file>\n"
msgstr " %s [选项] <文件>\n"

#: disk-utils/fsck.cramfs.c:114
msgid "Check and repair a compressed ROM filesystem.\n"
msgstr "检查并修复压缩的 ROM 文件系统。\n"

#: disk-utils/fsck.cramfs.c:117
msgid " -a                       for compatibility only, ignored\n"
msgstr " -a                       纯兼容性选项，忽略\n"

#: disk-utils/fsck.cramfs.c:118
msgid " -v, --verbose            be more verbose\n"
msgstr " -v, --verbose            更详尽\n"

#: disk-utils/fsck.cramfs.c:119
msgid " -y                       for compatibility only, ignored\n"
msgstr " -y                       纯兼容性选项，忽略\n"

#: disk-utils/fsck.cramfs.c:120
msgid " -b, --blocksize <size>   use this blocksize, defaults to page size\n"
msgstr " -b, --blocksize <大小>   使用指定的块大小，默认为页的大小\n"

#: disk-utils/fsck.cramfs.c:121
msgid "     --extract[=<dir>]    test uncompression, optionally extract into <dir>\n"
msgstr "     --extract[=<目录>]    测试解压，可指定解压到<目录>\n"

#: disk-utils/fsck.cramfs.c:158
#, c-format
msgid "ioctl failed: unable to determine device size: %s"
msgstr "ioctl 失败：无法确定设备大小：%s"

#: disk-utils/fsck.cramfs.c:164
#, c-format
msgid "not a block device or file: %s"
msgstr "不是一个块设备或文件：%s"

#: disk-utils/fsck.cramfs.c:167 disk-utils/fsck.cramfs.c:203
msgid "file length too short"
msgstr "文件长度过短"

#: disk-utils/fsck.cramfs.c:176 disk-utils/fsck.cramfs.c:231
#: disk-utils/fsck.cramfs.c:251 libfdisk/src/bsd.c:717 libfdisk/src/bsd.c:892
#: login-utils/last.c:203 login-utils/last.c:237 sys-utils/fallocate.c:202
#, c-format
msgid "seek on %s failed"
msgstr "在 %s 上定位失败"

#: disk-utils/fsck.cramfs.c:182 disk-utils/fsck.cramfs.c:184
msgid "superblock magic not found"
msgstr "超级块魔数(magic)未找到"

#: disk-utils/fsck.cramfs.c:187
#, c-format
msgid "cramfs endianness is %s\n"
msgstr "cramfs 大小端为 %s\n"

#: disk-utils/fsck.cramfs.c:188
msgid "big"
msgstr "大端"

#: disk-utils/fsck.cramfs.c:188
msgid "little"
msgstr "小端"

#: disk-utils/fsck.cramfs.c:192
msgid "unsupported filesystem features"
msgstr "不支持的文件系统特性"

#: disk-utils/fsck.cramfs.c:196
#, c-format
msgid "superblock size (%d) too small"
msgstr "超级块尺寸(%d)过小"

#: disk-utils/fsck.cramfs.c:201
msgid "zero file count"
msgstr "零文件计数"

#: disk-utils/fsck.cramfs.c:205
msgid "file extends past end of filesystem"
msgstr "警告：文件超过了文件系统终点"

#: disk-utils/fsck.cramfs.c:207
msgid "old cramfs format"
msgstr "旧的 cramfs 格式"

#: disk-utils/fsck.cramfs.c:216
msgid "unable to test CRC: old cramfs format"
msgstr "无法检测 CRC：旧的 cramfs 格式"

#: disk-utils/fsck.cramfs.c:236
#, fuzzy, c-format
msgid "failed to read %<PRIu32> bytes from file %s"
msgstr "读 typescript 文件 %s 失败"

#: disk-utils/fsck.cramfs.c:274
msgid "crc error"
msgstr "crc 错误"

#: disk-utils/fsck.cramfs.c:304 disk-utils/fsck.minix.c:560
msgid "seek failed"
msgstr "定位失败"

#: disk-utils/fsck.cramfs.c:308
msgid "read romfs failed"
msgstr "读取 romfs 失败"

#: disk-utils/fsck.cramfs.c:340
msgid "root inode is not directory"
msgstr "根 inode 不是一个目录"

#: disk-utils/fsck.cramfs.c:344
#, c-format
msgid "bad root offset (%lu)"
msgstr "错误的根偏移(%lu)"

#: disk-utils/fsck.cramfs.c:362
msgid "data block too large"
msgstr "数据块过大"

#: disk-utils/fsck.cramfs.c:366
#, c-format
msgid "decompression error: %s"
msgstr "解压出错：%s"

#: disk-utils/fsck.cramfs.c:392
#, c-format
msgid "  hole at %lu (%zu)\n"
msgstr "  位于 %lu 的空洞(%zu)\n"

#: disk-utils/fsck.cramfs.c:399 disk-utils/fsck.cramfs.c:552
#, c-format
msgid "  uncompressing block at %lu to %lu (%lu)\n"
msgstr "  正在将 %lu 处的块解压到 %lu (%lu)\n"

#: disk-utils/fsck.cramfs.c:406
#, c-format
msgid "non-block (%ld) bytes"
msgstr "非块(%ld)字节 "

#: disk-utils/fsck.cramfs.c:410
#, c-format
msgid "non-size (%ld vs %ld) bytes"
msgstr "无大小(%ld ： %ld)字节"

#: disk-utils/fsck.cramfs.c:415 disk-utils/fsck.cramfs.c:518
#: disk-utils/swaplabel.c:109 misc-utils/uuidd.c:366 sys-utils/fallocate.c:408
#: sys-utils/rfkill.c:551 sys-utils/setpriv.c:620 sys-utils/setpriv.c:643
#: sys-utils/swapon.c:393 term-utils/ttymsg.c:175
#, c-format
msgid "write failed: %s"
msgstr "写失败：%s"

#: disk-utils/fsck.cramfs.c:426
#, c-format
msgid "lchown failed: %s"
msgstr "lchown 失败：%s"

#: disk-utils/fsck.cramfs.c:430
#, c-format
msgid "chown failed: %s"
msgstr "chown 失败：%s"

#: disk-utils/fsck.cramfs.c:435
#, c-format
msgid "utime failed: %s"
msgstr "utime 失败：%s"

#: disk-utils/fsck.cramfs.c:447
#, c-format
msgid "directory inode has zero offset and non-zero size: %s"
msgstr "目录 inode 偏移为 0，大小不为 0：%s"

#: disk-utils/fsck.cramfs.c:462
#, c-format
msgid "mkdir failed: %s"
msgstr "mkdir 失败：%s"

#: disk-utils/fsck.cramfs.c:478
msgid "filename length is zero"
msgstr "文件名长度为 0"

#: disk-utils/fsck.cramfs.c:480
msgid "bad filename length"
msgstr "文件名长度有误"

#: disk-utils/fsck.cramfs.c:486
msgid "bad inode offset"
msgstr "inode 偏移有误"

#: disk-utils/fsck.cramfs.c:501
msgid "file inode has zero offset and non-zero size"
msgstr "文件 inode 偏移为 0，大小不为 0"

#: disk-utils/fsck.cramfs.c:504
msgid "file inode has zero size and non-zero offset"
msgstr "文件 inode 大小为 0，偏移不为 0"

#: disk-utils/fsck.cramfs.c:533
msgid "symbolic link has zero offset"
msgstr "符号链接偏移为 0"

#: disk-utils/fsck.cramfs.c:535
msgid "symbolic link has zero size"
msgstr "符号链接大小为 0"

#: disk-utils/fsck.cramfs.c:544
#, c-format
msgid "size error in symlink: %s"
msgstr "符号链接大小出错：%s"

#: disk-utils/fsck.cramfs.c:558
#, c-format
msgid "symlink failed: %s"
msgstr "symlink 失败：%s"

#: disk-utils/fsck.cramfs.c:571
#, c-format
msgid "special file has non-zero offset: %s"
msgstr "特殊文件的偏移不为 0：%s"

#: disk-utils/fsck.cramfs.c:581
#, c-format
msgid "fifo has non-zero size: %s"
msgstr "FIFO 的大小不为 0：%s"

#: disk-utils/fsck.cramfs.c:587
#, c-format
msgid "socket has non-zero size: %s"
msgstr "套接字的大小不为 0：%s"

#: disk-utils/fsck.cramfs.c:590
#, c-format
msgid "bogus mode: %s (%o)"
msgstr "伪(bogus)模式：%s (%o)"

#: disk-utils/fsck.cramfs.c:599
#, c-format
msgid "mknod failed: %s"
msgstr "mknod 失败：%s"

#: disk-utils/fsck.cramfs.c:631
#, c-format
msgid "directory data start (%lu) < sizeof(struct cramfs_super) + start (%zu)"
msgstr "目录数据起点(%lu) < sizeof(struct cramfs_super) + 起点 (%zu)"

#: disk-utils/fsck.cramfs.c:635
#, c-format
msgid "directory data end (%lu) != file data start (%lu)"
msgstr "目录数据终点 (%lu) != 文件数据起点 (%lu)"

#: disk-utils/fsck.cramfs.c:639
msgid "invalid file data offset"
msgstr "无效的文件数据偏移"

#: disk-utils/fsck.cramfs.c:688 disk-utils/mkfs.cramfs.c:736
msgid "invalid blocksize argument"
msgstr "无效的 块大小 参数"

#: disk-utils/fsck.cramfs.c:711
#, c-format
msgid "%s: OK\n"
msgstr "%s：OK\n"

#: disk-utils/fsck.minix.c:185
msgid "Check the consistency of a Minix filesystem.\n"
msgstr "检查 Minix 文件系统的一致性。\n"

#: disk-utils/fsck.minix.c:187
msgid " -l, --list       list all filenames\n"
msgstr " -l, --list       列出所有文件名\n"

#: disk-utils/fsck.minix.c:188
msgid " -a, --auto       automatic repair\n"
msgstr " -a, --auto      自动修复\n"

#: disk-utils/fsck.minix.c:189
msgid " -r, --repair     interactive repair\n"
msgstr " -r, --repair     交互修复\n"

#: disk-utils/fsck.minix.c:190
msgid " -v, --verbose    be verbose\n"
msgstr " -v, --verbose    详尽方式\n"

#: disk-utils/fsck.minix.c:191
msgid " -s, --super      output super-block information\n"
msgstr " -s, --super      输出超级块信息\n"

#: disk-utils/fsck.minix.c:192
msgid " -m, --uncleared  activate mode not cleared warnings\n"
msgstr " -m, --uncleared  激活 模式未清除 警告\n"

#: disk-utils/fsck.minix.c:193
msgid " -f, --force      force check\n"
msgstr " -f, --force      强制检查\n"

#. TRANSLATORS: these yes no questions uses rpmatch(), and should be
#. * translated.
#: disk-utils/fsck.minix.c:252
#, c-format
msgid "%s (y/n)? "
msgstr "%s (是/否)? "

#: disk-utils/fsck.minix.c:252
#, c-format
msgid "%s (n/y)? "
msgstr "%s (否/是)? "

#: disk-utils/fsck.minix.c:269
#, c-format
msgid "y\n"
msgstr "是\n"

#: disk-utils/fsck.minix.c:271
#, c-format
msgid "n\n"
msgstr "否\n"

#: disk-utils/fsck.minix.c:287
#, c-format
msgid "%s is mounted.\t "
msgstr "%s 已经挂载.\t"

#: disk-utils/fsck.minix.c:289
msgid "Do you really want to continue"
msgstr "你确认要继续"

#: disk-utils/fsck.minix.c:293
#, c-format
msgid "check aborted.\n"
msgstr "检查失败.\n"

#: disk-utils/fsck.minix.c:319 disk-utils/fsck.minix.c:340
#, c-format
msgid "Zone nr < FIRSTZONE in file `%s'."
msgstr "nr 区 < 文件“%s”中的 FIRSTZONE。"

#: disk-utils/fsck.minix.c:322 disk-utils/fsck.minix.c:343
#, c-format
msgid "Zone nr >= ZONES in file `%s'."
msgstr "nr 区 >= 文件“%s”中的 FIRSTZONE。"

#: disk-utils/fsck.minix.c:326 disk-utils/fsck.minix.c:347
msgid "Remove block"
msgstr "删除块"

#: disk-utils/fsck.minix.c:363
#, c-format
msgid "Read error: unable to seek to block in file '%s'\n"
msgstr "读取错误: 不能在文件 '%s' 中定位到该块\n"

#: disk-utils/fsck.minix.c:369
#, c-format
msgid "Read error: bad block in file '%s'\n"
msgstr "读取错误: 文件 '%s' 中有坏块\n"

#: disk-utils/fsck.minix.c:381
#, c-format
msgid ""
"Internal error: trying to write bad block\n"
"Write request ignored\n"
msgstr ""
"内部错误: 试图写坏块\n"
"写请求忽略\n"

#: disk-utils/fsck.minix.c:387
msgid "seek failed in write_block"
msgstr "在 write_block 中定位失败"

#: disk-utils/fsck.minix.c:390
#, c-format
msgid "Write error: bad block in file '%s'\n"
msgstr "写入错误: 文件 '%s' 中有坏块\n"

#: disk-utils/fsck.minix.c:424
#, fuzzy, c-format
msgid "Warning: block out of range\n"
msgstr "警告: inode 计数太大.\n"

#: disk-utils/fsck.minix.c:511
msgid "seek failed in write_super_block"
msgstr "在 write_super_block 中定位失败"

#: disk-utils/fsck.minix.c:513
msgid "unable to write super-block"
msgstr "不能写超级块"

#: disk-utils/fsck.minix.c:526
msgid "Unable to write inode map"
msgstr "不能写 inode map"

#: disk-utils/fsck.minix.c:529
msgid "Unable to write zone map"
msgstr "不能写 zone map"

#: disk-utils/fsck.minix.c:532
msgid "Unable to write inodes"
msgstr "不能写 inodes"

#: disk-utils/fsck.minix.c:564
msgid "unable to alloc buffer for superblock"
msgstr "无法为超级块分配缓冲区"

#: disk-utils/fsck.minix.c:567
msgid "unable to read super block"
msgstr "不能读超级块"

#: disk-utils/fsck.minix.c:589
msgid "bad magic number in super-block"
msgstr "超级块中的魔数数字损坏"

#: disk-utils/fsck.minix.c:591
msgid "Only 1k blocks/zones supported"
msgstr "只支持 1k 块/区"

#: disk-utils/fsck.minix.c:593
msgid "bad s_ninodes field in super-block"
msgstr "超级块中有不正确的 s_ninodes 字段"

#: disk-utils/fsck.minix.c:595
msgid "bad s_imap_blocks field in super-block"
msgstr "不正确的 s_imap_blocks 域在超级块中"

#: disk-utils/fsck.minix.c:597
msgid "bad s_firstdatazone field in super-block"
msgstr "超级块中有不正确的 s_firstdatazone 字段"

#: disk-utils/fsck.minix.c:600
msgid "bad s_zmap_blocks field in super-block"
msgstr "不正确的 s_zmap_blocks 域在超级块中"

#: disk-utils/fsck.minix.c:616
msgid "Unable to allocate buffer for inode map"
msgstr "不能为 inode map 分配缓冲区"

#: disk-utils/fsck.minix.c:619
msgid "Unable to allocate buffer for zone map"
msgstr "不能为 zone map 分配缓冲区"

#: disk-utils/fsck.minix.c:622
msgid "Unable to allocate buffer for inodes"
msgstr "不能为 inodes 分配缓冲区"

#: disk-utils/fsck.minix.c:625
msgid "Unable to allocate buffer for inode count"
msgstr "不能为 inode count 分配缓冲区"

#: disk-utils/fsck.minix.c:628
msgid "Unable to allocate buffer for zone count"
msgstr "不能为 zone count 分配缓冲区"

#: disk-utils/fsck.minix.c:632
msgid "Unable to read inode map"
msgstr "不能读 inode map"

#: disk-utils/fsck.minix.c:636
msgid "Unable to read zone map"
msgstr "不能读 zone map"

#: disk-utils/fsck.minix.c:640
msgid "Unable to read inodes"
msgstr "不能读 inodes"

#: disk-utils/fsck.minix.c:642
#, c-format
msgid "Warning: Firstzone != Norm_firstzone\n"
msgstr "警告: Firstzone != Norm_firstzone\n"

#: disk-utils/fsck.minix.c:647
#, c-format
msgid "%ld inodes\n"
msgstr "%ld 个inode\n"

#: disk-utils/fsck.minix.c:648
#, c-format
msgid "%ld blocks\n"
msgstr "%ld 块\n"

#: disk-utils/fsck.minix.c:649 disk-utils/mkfs.minix.c:568
#, c-format
msgid "Firstdatazone=%jd (%jd)\n"
msgstr "首个数据区=%jd (%jd)\n"

#: disk-utils/fsck.minix.c:651
#, c-format
msgid "Zonesize=%d\n"
msgstr "区大小=%d\n"

#: disk-utils/fsck.minix.c:652
#, c-format
msgid "Maxsize=%zu\n"
msgstr "最大尺寸=%zu\n"

#: disk-utils/fsck.minix.c:654
#, c-format
msgid "Filesystem state=%d\n"
msgstr "文件系统状态=%d\n"

#: disk-utils/fsck.minix.c:655
#, c-format
msgid ""
"namelen=%zd\n"
"\n"
msgstr ""
"名称长度=%zd\n"
"\n"

#: disk-utils/fsck.minix.c:670 disk-utils/fsck.minix.c:720
#, c-format
msgid "Inode %d marked unused, but used for file '%s'\n"
msgstr "Inode %d 标记为未使用, 但用于文件 '%s'\n"

#: disk-utils/fsck.minix.c:673 disk-utils/fsck.minix.c:723
msgid "Mark in use"
msgstr "标记为已使用"

#: disk-utils/fsck.minix.c:695 disk-utils/fsck.minix.c:743
#, c-format
msgid "The file `%s' has mode %05o\n"
msgstr "文件 `%s' 的模式 %05o\n"

#: disk-utils/fsck.minix.c:702 disk-utils/fsck.minix.c:749
#, c-format
msgid "Warning: inode count too big.\n"
msgstr "警告: inode 计数太大.\n"

#: disk-utils/fsck.minix.c:761 disk-utils/fsck.minix.c:769
msgid "root inode isn't a directory"
msgstr "根 inode 不是一个目录"

#: disk-utils/fsck.minix.c:781 disk-utils/fsck.minix.c:812
#, c-format
msgid "Block has been used before. Now in file `%s'."
msgstr "块已经被使用, 现在在文件 `%s' 中."

#: disk-utils/fsck.minix.c:783 disk-utils/fsck.minix.c:814
#: disk-utils/fsck.minix.c:1149 disk-utils/fsck.minix.c:1158
#: disk-utils/fsck.minix.c:1205 disk-utils/fsck.minix.c:1214
msgid "Clear"
msgstr "清除"

#: disk-utils/fsck.minix.c:793 disk-utils/fsck.minix.c:824
#, c-format
msgid "Block %d in file `%s' is marked not in use."
msgstr "文件中块 %d `%s' 标记为没有使用."

#: disk-utils/fsck.minix.c:795 disk-utils/fsck.minix.c:826
msgid "Correct"
msgstr "正确"

#: disk-utils/fsck.minix.c:965 disk-utils/fsck.minix.c:1039
#, c-format
msgid "The directory '%s' contains a bad inode number for file '%.*s'."
msgstr "目录 '%s' 包含了一个不正确的 inode number 文件 '%.*s'. "

#: disk-utils/fsck.minix.c:967 disk-utils/fsck.minix.c:1041
msgid " Remove"
msgstr " 删除"

#: disk-utils/fsck.minix.c:983 disk-utils/fsck.minix.c:1057
#, c-format
msgid "%s: bad directory: '.' isn't first\n"
msgstr "%s: 不正确的目录: '.' 不是第一个\n"

#: disk-utils/fsck.minix.c:992 disk-utils/fsck.minix.c:1066
#, c-format
msgid "%s: bad directory: '..' isn't second\n"
msgstr "%s: 不正确的目录: '.' 不是第二个\n"

#: disk-utils/fsck.minix.c:1100 disk-utils/fsck.minix.c:1123
msgid "internal error"
msgstr "内部错误"

#: disk-utils/fsck.minix.c:1103 disk-utils/fsck.minix.c:1126
#, c-format
msgid "%s: bad directory: size < 32"
msgstr "%s: 不正确的目录: 大小 < 32"

#: disk-utils/fsck.minix.c:1109
#, c-format
msgid "%s: bad directory: invalid i_zone, use --repair to fix\n"
msgstr "%s: 目录错误: i_zone 无效，请用 --repair 修复\n"

#: disk-utils/fsck.minix.c:1138
msgid "seek failed in bad_zone"
msgstr "bad_zone 中定位失败"

#: disk-utils/fsck.minix.c:1148 disk-utils/fsck.minix.c:1204
#, c-format
msgid "Inode %lu mode not cleared."
msgstr "Inode %lu 模式未清除。"

#: disk-utils/fsck.minix.c:1157 disk-utils/fsck.minix.c:1213
#, c-format
msgid "Inode %lu not used, marked used in the bitmap."
msgstr "Inode %lu 未使用，但在位图(bitmap)中标记为已使用。"

#: disk-utils/fsck.minix.c:1163 disk-utils/fsck.minix.c:1219
#, c-format
msgid "Inode %lu used, marked unused in the bitmap."
msgstr "Inode %lu 已使用，但在位图(bitmap)中标记为未使用。"

#: disk-utils/fsck.minix.c:1164 disk-utils/fsck.minix.c:1220
msgid "Set"
msgstr "设置"

#: disk-utils/fsck.minix.c:1168 disk-utils/fsck.minix.c:1224
#, c-format
msgid "Inode %lu (mode = %07o), i_nlinks=%d, counted=%d."
msgstr "Inode %lu (模式 = %07o), i_nlinks=%d, 已计数=%d。"

#: disk-utils/fsck.minix.c:1171 disk-utils/fsck.minix.c:1227
msgid "Set i_nlinks to count"
msgstr "将 i_nlinks 设为计数"

#: disk-utils/fsck.minix.c:1183 disk-utils/fsck.minix.c:1239
#, c-format
msgid "Zone %lu: marked in use, no file uses it."
msgstr "%lu 区：标记为使用，但没有文件使用它。"

#: disk-utils/fsck.minix.c:1185 disk-utils/fsck.minix.c:1241
msgid "Unmark"
msgstr "清标记"

#: disk-utils/fsck.minix.c:1190 disk-utils/fsck.minix.c:1246
#, c-format
msgid "Zone %lu: in use, counted=%d\n"
msgstr "区 %lu：使用中，已计数=%d\n"

#: disk-utils/fsck.minix.c:1193 disk-utils/fsck.minix.c:1249
#, c-format
msgid "Zone %lu: not in use, counted=%d\n"
msgstr "区 %lu：未使用，已计数=%d\n"

#: disk-utils/fsck.minix.c:1299
msgid "bad inode size"
msgstr "inode 大小有误"

#: disk-utils/fsck.minix.c:1301
msgid "bad v2 inode size"
msgstr "v2 inode 大小有误"

#: disk-utils/fsck.minix.c:1346
msgid "need terminal for interactive repairs"
msgstr "需要终端来进行交互式修复"

#: disk-utils/fsck.minix.c:1350
#, c-format
msgid "cannot open %s: %s"
msgstr "无法打开 %s：%s"

#: disk-utils/fsck.minix.c:1361
#, c-format
msgid "%s is clean, no check.\n"
msgstr "%s 是干净的，不检查。\n"

#: disk-utils/fsck.minix.c:1364
#, c-format
msgid "Forcing filesystem check on %s.\n"
msgstr "强制在 %s 上进行文件系统检查。\n"

#: disk-utils/fsck.minix.c:1366
#, c-format
msgid "Filesystem on %s is dirty, needs checking.\n"
msgstr "%s 上的文件系统有问题，需要检查。\n"

#: disk-utils/fsck.minix.c:1398
#, c-format
msgid ""
"\n"
"%6ld inodes used (%ld%%)\n"
msgstr ""
"\n"
"已使用 %6ld inodes(%ld%%)\n"

#: disk-utils/fsck.minix.c:1404
#, c-format
msgid "%6ld zones used (%ld%%)\n"
msgstr "已使用 %6ld 区(%ld%%)\n"

#: disk-utils/fsck.minix.c:1406
#, c-format
msgid ""
"\n"
"%6d regular files\n"
"%6d directories\n"
"%6d character device files\n"
"%6d block device files\n"
"%6d links\n"
"%6d symbolic links\n"
"------\n"
"%6d files\n"
msgstr ""
"\n"
"%6d 个常规文件\n"
"%6d 个目录\n"
"%6d 个字符设备文件\n"
"%6d 个块设备文件\n"
"%6d 个链接\n"
"%6d 个符号链接\n"
"------\n"
"%6d 个文件\n"

#: disk-utils/fsck.minix.c:1420
#, c-format
msgid ""
"----------------------------\n"
"FILE SYSTEM HAS BEEN CHANGED\n"
"----------------------------\n"
msgstr ""
"----------------\n"
"文件系统已经更改\n"
"----------------\n"

#: disk-utils/fsck.minix.c:1432 disk-utils/mkfs.minix.c:838
#: disk-utils/mkswap.c:541 disk-utils/partx.c:1058 disk-utils/resizepart.c:114
#: login-utils/su-common.c:323 login-utils/su-common.c:400
#: login-utils/utmpdump.c:391 sys-utils/dmesg.c:661 sys-utils/wdctl.c:347
#: sys-utils/wdctl.c:412 term-utils/script.c:298 term-utils/script.c:375
#: term-utils/setterm.c:887 text-utils/pg.c:1256
msgid "write failed"
msgstr "写失败"

#: disk-utils/isosize.c:106
#, c-format
msgid "%s: might not be an ISO filesystem"
msgstr "%s：可能不是 ISO 文件系统"

#: disk-utils/isosize.c:111 disk-utils/isosize.c:113
#, c-format
msgid "read error on %s"
msgstr "%s 读出错"

#: disk-utils/isosize.c:124
#, c-format
msgid "sector count: %d, sector size: %d\n"
msgstr "扇区计数：%d，扇区大小：%d\n"

#: disk-utils/isosize.c:148
#, fuzzy, c-format
msgid " %s [options] <iso9660_image_file> ...\n"
msgstr " %s [选项] <iso9660镜像文件>\n"

#: disk-utils/isosize.c:152
msgid "Show the length of an ISO-9660 filesystem.\n"
msgstr "显示 ISO-9660 文件系统的长度。\n"

#: disk-utils/isosize.c:155
msgid " -d, --divisor=<number>  divide the amount of bytes by <number>\n"
msgstr " -d, --divisor=<数字>    将字节数除以 <数字>\n"

#: disk-utils/isosize.c:156
msgid " -x, --sectors           show sector count and size\n"
msgstr " -x, --sectors           显示扇区计数和大小\n"

#: disk-utils/isosize.c:187
msgid "invalid divisor argument"
msgstr "无效的 divisor(除数) 参数"

#: disk-utils/mkfs.bfs.c:74
#, c-format
msgid "Usage: %s [options] device [block-count]\n"
msgstr "Usage: %s [选项] 设备 [块数]\n"

#: disk-utils/mkfs.bfs.c:78
msgid "Make an SCO bfs filesystem.\n"
msgstr "制作 SCO bfs 文件系统。\n"

#: disk-utils/mkfs.bfs.c:80
#, fuzzy, c-format
msgid ""
"\n"
"Options:\n"
" -N, --inodes=NUM    specify desired number of inodes\n"
" -V, --vname=NAME    specify volume name\n"
" -F, --fname=NAME    specify file system name\n"
" -v, --verbose       explain what is being done\n"
" -c                  this option is silently ignored\n"
" -l                  this option is silently ignored\n"
msgstr ""
"\n"
"选项有：\n"
" -N, --inodes=NUM    指定希望的 inodes 数目\n"
" -V, --vname=NAME    指定卷名\n"
" -F, --fname=NAME    指定文件系统名\n"
" -v, --verbose       解释正在进行的操作\n"
" -c                  此选项将被忽略，不做提示\n"
" -l                  此选项将被忽略，不做提示\n"
" -V, --version       输出版本信息并退出\n"
"                     -V 大写以示不能与其他选项合用\n"
" -h, --help          显示此帮助并退出\n"
"\n"

#: disk-utils/mkfs.bfs.c:145
msgid "invalid number of inodes"
msgstr "无效的 inodes 数目"

#: disk-utils/mkfs.bfs.c:151
msgid "volume name too long"
msgstr "卷名过长"

#: disk-utils/mkfs.bfs.c:158
msgid "fsname name too long"
msgstr "fsname 名过长"

#: disk-utils/mkfs.bfs.c:196
msgid "invalid block-count"
msgstr "无效的块计数"

#: disk-utils/mkfs.bfs.c:204
#, c-format
msgid "cannot get size of %s"
msgstr "无法获得 %s 的大小"

#: disk-utils/mkfs.bfs.c:209
#, c-format
msgid "blocks argument too large, max is %llu"
msgstr "块参数过大，最大值是 %llu"

#: disk-utils/mkfs.bfs.c:224
msgid "too many inodes - max is 512"
msgstr "inodes 过多 - 最多 512"

#: disk-utils/mkfs.bfs.c:234
#, c-format
msgid "not enough space, need at least %llu blocks"
msgstr "空间不足，至少需要 %llu 个块"

#: disk-utils/mkfs.bfs.c:246
#, c-format
msgid "Device: %s\n"
msgstr "设备：%s\n"

#: disk-utils/mkfs.bfs.c:247
#, c-format
msgid "Volume: <%-6s>\n"
msgstr "卷：<%-6s>\n"

#: disk-utils/mkfs.bfs.c:248
#, c-format
msgid "FSname: <%-6s>\n"
msgstr "文件系统名：<%-6s>\n"

#: disk-utils/mkfs.bfs.c:249
#, c-format
msgid "BlockSize: %d\n"
msgstr "块大小：%d\n"

#: disk-utils/mkfs.bfs.c:251
#, c-format
msgid "Inodes: %ld (in 1 block)\n"
msgstr "Inodes：%ld (在 1 个块中)\n"

#: disk-utils/mkfs.bfs.c:254
#, c-format
msgid "Inodes: %ld (in %llu blocks)\n"
msgstr "Inodes：%ld (在 %llu 个块中)\n"

#: disk-utils/mkfs.bfs.c:256
#, c-format
msgid "Blocks: %llu\n"
msgstr "块：%llu\n"

#: disk-utils/mkfs.bfs.c:257
#, c-format
msgid "Inode end: %d, Data end: %d\n"
msgstr "Inode 终点：%d，数据终点：%d\n"

#: disk-utils/mkfs.bfs.c:262
msgid "error writing superblock"
msgstr "写超级块出错"

#: disk-utils/mkfs.bfs.c:283
msgid "error writing root inode"
msgstr "写 根 inode 出错"

#: disk-utils/mkfs.bfs.c:288
msgid "error writing inode"
msgstr "写 inode 出错"

#: disk-utils/mkfs.bfs.c:291
msgid "seek error"
msgstr "定位出错"

#: disk-utils/mkfs.bfs.c:297
msgid "error writing . entry"
msgstr "写 . 记录出错"

#: disk-utils/mkfs.bfs.c:301
msgid "error writing .. entry"
msgstr "写 .. 记录出错"

#: disk-utils/mkfs.bfs.c:304
#, c-format
msgid "error closing %s"
msgstr "关闭 %s 出错"

#: disk-utils/mkfs.c:45
#, c-format
msgid " %s [options] [-t <type>] [fs-options] <device> [<size>]\n"
msgstr " %s [选项] [-t <类型>] [文件系统选项] <设备> [<大小>]\n"

#: disk-utils/mkfs.c:49
msgid "Make a Linux filesystem.\n"
msgstr "创建一个Linux 文件系统。\n"

#: disk-utils/mkfs.c:52
#, c-format
msgid " -t, --type=<type>  filesystem type; when unspecified, ext2 is used\n"
msgstr " -t, --type=<类型>  文件系统类型；若不指定，将使用 ext2\n"

#: disk-utils/mkfs.c:53
#, c-format
msgid "     fs-options     parameters for the real filesystem builder\n"
msgstr "     fs-options     实际文件系统构建程序的参数\n"

#: disk-utils/mkfs.c:54
#, c-format
msgid "     <device>       path to the device to be used\n"
msgstr "     <设备>         要使用设备的路径\n"

#: disk-utils/mkfs.c:55
#, c-format
msgid "     <size>         number of blocks to be used on the device\n"
msgstr "     <大小>         要使用设备上的块数\n"

#: disk-utils/mkfs.c:56
#, c-format
msgid ""
" -V, --verbose      explain what is being done;\n"
"                      specifying -V more than once will cause a dry-run\n"
msgstr ""
" -V, --verbose      解释正在进行的操作；\n"
"                      多次指定 -V 将导致空运行(dry-run)\n"

#: disk-utils/mkfs.c:139 include/c.h:223 login-utils/su-common.c:1435
#: login-utils/sulogin.c:791 login-utils/sulogin.c:795 sys-utils/flock.c:121
#: sys-utils/rtcwake.c:595 term-utils/script.c:618
#, c-format
msgid "failed to execute %s"
msgstr "执行 %s 失败"

#: disk-utils/mkfs.cramfs.c:128
#, fuzzy, c-format
msgid ""
"usage: %s [-h] [-v] [-b blksize] [-e edition] [-N endian] [-i file] [-n name] dirname outfile\n"
" -v         be verbose\n"
" -E         make all warnings errors (non-zero exit status)\n"
" -b blksize use this blocksize, must equal page size\n"
" -e edition set edition number (part of fsid)\n"
" -N endian  set cramfs endianness (big|little|host), default host\n"
" -i file    insert a file image into the filesystem\n"
" -n name    set name of cramfs filesystem\n"
" -p         pad by %d bytes for boot code\n"
" -s         sort directory entries (old option, ignored)\n"
" -z         make explicit holes\n"
" dirname    root of the filesystem to be compressed\n"
" outfile    output file\n"
msgstr ""
"用法：%s [-h] [-v] [-b 块大小] [-e 版本] [-N 大小端] [-i 文件] [-n 名称] 目录名 输出文件\n"
" -h         打印此帮助\n"
" -v         详尽模式\n"
" -E         将所有警告视为错误(退出状态码非 0)\n"
" -b 块大小  使用此 块大小，必须与页大小相同\n"
" -e 版本    设置修订版本号(fsid 的一部分)\n"
" -N 大小端  设置 cramfs 大小端(big|little|host)，默认为 host\n"
" -i 文件    将文件镜像插入文件系统(要求 >= 2.4.0)\n"
" -n 名称    设置cramfs 文件系统名称\n"
" -p         用于启动代码的 %d 字节的 pad 区\n"
" -s         对目录记录进行排序(旧选项，会被忽略)\n"
" -z         产生显式空洞 (要求 >= 2.3.39)\n"
" 目录名     要压缩的文件系统的根目录\n"
" 输出文件   输出文件\n"

#: disk-utils/mkfs.cramfs.c:162
#, c-format
msgid "readlink failed: %s"
msgstr "readlink 失败：%s"

#: disk-utils/mkfs.cramfs.c:307
#, c-format
msgid "could not read directory %s"
msgstr "无法读目录 %s"

#: disk-utils/mkfs.cramfs.c:442
msgid "filesystem too big.  Exiting."
msgstr "文件系统过大。将退出。"

#: disk-utils/mkfs.cramfs.c:601
#, c-format
msgid "AIEEE: block \"compressed\" to > 2*blocklength (%ld)\n"
msgstr "AIEEE：块已“压缩”到 > 2*块长度(%ld)\n"

#: disk-utils/mkfs.cramfs.c:620
#, c-format
msgid "%6.2f%% (%+ld bytes)\t%s\n"
msgstr "%6.2f%% (%+ld 字节)\t%s\n"

#: disk-utils/mkfs.cramfs.c:665
#, c-format
msgid "cannot close file %s"
msgstr "无法关闭文件 %s"

#: disk-utils/mkfs.cramfs.c:742
msgid "invalid edition number argument"
msgstr "无效的修订版本号参数"

#: disk-utils/mkfs.cramfs.c:752
msgid "invalid endianness given; must be 'big', 'little', or 'host'"
msgstr "给定的大小端无效。必须为“big”、“little”或“host”"

#: disk-utils/mkfs.cramfs.c:818
#, c-format
msgid "warning: guestimate of required size (upper bound) is %lldMB, but maximum image size is %uMB.  We might die prematurely."
msgstr "警告：估计需要的大小(上限)为 %lldMB，但最大镜像大小为 %uMB。程序可能提前终止(die)。"

#: disk-utils/mkfs.cramfs.c:842
msgid "ROM image map"
msgstr "ROM 镜像映射"

#: disk-utils/mkfs.cramfs.c:854
#, c-format
msgid "Including: %s\n"
msgstr "包含：%s\n"

#: disk-utils/mkfs.cramfs.c:860
#, c-format
msgid "Directory data: %zd bytes\n"
msgstr "目录数据：%zd 字节\n"

#: disk-utils/mkfs.cramfs.c:868
#, c-format
msgid "Everything: %zd kilobytes\n"
msgstr "全部：%zd KB\n"

#: disk-utils/mkfs.cramfs.c:873
#, c-format
msgid "Super block: %zd bytes\n"
msgstr "超级块：%zd 字节\n"

#: disk-utils/mkfs.cramfs.c:880
#, c-format
msgid "CRC: %x\n"
msgstr "CRC：%x\n"

#: disk-utils/mkfs.cramfs.c:885
#, c-format
msgid "not enough space allocated for ROM image (%lld allocated, %zu used)"
msgstr "为 ROM 镜像分配的空间不足(已分配 %lld，已使用 %zu)"

#: disk-utils/mkfs.cramfs.c:891
#, c-format
msgid "ROM image write failed (%zd %zd)"
msgstr "写 ROM 镜像失败(%zd %zd)"

#: disk-utils/mkfs.cramfs.c:894
msgid "ROM image"
msgstr "ROM 镜像"

#: disk-utils/mkfs.cramfs.c:903
#, c-format
msgid "warning: filenames truncated to %u bytes."
msgstr "警告：文件名被截短为 %u 个字节。"

#: disk-utils/mkfs.cramfs.c:905
msgid "warning: files were skipped due to errors."
msgstr "警告：由于错误，文件被跳过。"

#: disk-utils/mkfs.cramfs.c:907
#, c-format
msgid "warning: file sizes truncated to %luMB (minus 1 byte)."
msgstr "警告：文件大小被截短为 %luMB(减 1 字节)。"

#: disk-utils/mkfs.cramfs.c:911
#, c-format
msgid "warning: uids truncated to %u bits.  (This may be a security concern.)"
msgstr "警告：uid 被截短为 %u 位。(可能有安全隐患。)"

#: disk-utils/mkfs.cramfs.c:914
#, c-format
msgid "warning: gids truncated to %u bits.  (This may be a security concern.)"
msgstr "警告：gid 被截短为 %u 位。(可能有安全隐患。)"

#: disk-utils/mkfs.cramfs.c:917
#, c-format
msgid ""
"WARNING: device numbers truncated to %u bits.  This almost certainly means\n"
"that some device files will be wrong."
msgstr "警告：设备号被截短为 %u 位。几乎可以肯定某些设备文件将出错。"

#: disk-utils/mkfs.minix.c:138
#, c-format
msgid " %s [options] /dev/name [blocks]\n"
msgstr " %s [选项] /dev/name [块数]\n"

#: disk-utils/mkfs.minix.c:140
msgid " -1                      use Minix version 1\n"
msgstr " -1                      使用 Minix 第 1 版\n"

#: disk-utils/mkfs.minix.c:141
msgid " -2, -v                  use Minix version 2\n"
msgstr " -2, -v                  使用 Minix 第 2 版\n"

#: disk-utils/mkfs.minix.c:142
msgid " -3                      use Minix version 3\n"
msgstr " -3                      使用 Minix 第 3 版\n"

#: disk-utils/mkfs.minix.c:143
msgid " -n, --namelength <num>  maximum length of filenames\n"
msgstr " -n, --namelength <数字> 文件名的最大长度\n"

#: disk-utils/mkfs.minix.c:144
msgid " -i, --inodes <num>      number of inodes for the filesystem\n"
msgstr " -i, --inodes <数字>     文件系统的 inode 数\n"

#: disk-utils/mkfs.minix.c:145
msgid " -c, --check             check the device for bad blocks\n"
msgstr " -c, --check             检查设备坏块\n"

#: disk-utils/mkfs.minix.c:146
msgid " -l, --badblocks <file>  list of bad blocks from file\n"
msgstr " -l, --badblocks <文件>  列出文件中的坏块\n"

#: disk-utils/mkfs.minix.c:189
#, c-format
msgid "%s: seek to boot block failed  in write_tables"
msgstr "%s：在 write_tables 中定位到启动块失败"

#: disk-utils/mkfs.minix.c:192
#, c-format
msgid "%s: unable to clear boot sector"
msgstr "%s：无法清除启动扇区"

#: disk-utils/mkfs.minix.c:194
#, c-format
msgid "%s: seek failed in write_tables"
msgstr "%s：在 write_tables 中定位失败"

#: disk-utils/mkfs.minix.c:197
#, c-format
msgid "%s: unable to write super-block"
msgstr "%s：无法写超级块"

#: disk-utils/mkfs.minix.c:200
#, c-format
msgid "%s: unable to write inode map"
msgstr "%s：无法写 inode map"

#: disk-utils/mkfs.minix.c:203
#, c-format
msgid "%s: unable to write zone map"
msgstr "%s：无法写 zone map"

#: disk-utils/mkfs.minix.c:206
#, c-format
msgid "%s: unable to write inodes"
msgstr "%s：无法写 inodes"

#: disk-utils/mkfs.minix.c:211
#, c-format
msgid "%s: seek failed in write_block"
msgstr "%s：在 write_block 中定位失败"

#: disk-utils/mkfs.minix.c:214
#, c-format
msgid "%s: write failed in write_block"
msgstr "%s：在 write_block 中写入失败"

#: disk-utils/mkfs.minix.c:223 disk-utils/mkfs.minix.c:298
#: disk-utils/mkfs.minix.c:347
#, c-format
msgid "%s: too many bad blocks"
msgstr "%s：坏块太多"

#: disk-utils/mkfs.minix.c:231
#, c-format
msgid "%s: not enough good blocks"
msgstr "%s：好块不够"

#: disk-utils/mkfs.minix.c:546
#, c-format
msgid ""
"First data block at %jd, which is too far (max %d).\n"
"Try specifying fewer inodes by passing --inodes <num>"
msgstr ""
"第一个数据块位于 %jd，过远(最大为 %d)。\n"
"请尝试通过传递 --inodes <数值> 来指定更少的 inode"

#: disk-utils/mkfs.minix.c:566
#, c-format
msgid "%lu inode\n"
msgid_plural "%lu inodes\n"
msgstr[0] "%lu 个 inode\n"

#: disk-utils/mkfs.minix.c:567
#, c-format
msgid "%lu block\n"
msgid_plural "%lu blocks\n"
msgstr[0] "%lu 个块\n"

#: disk-utils/mkfs.minix.c:570
#, c-format
msgid "Zonesize=%zu\n"
msgstr "区大小=%zu\n"

#: disk-utils/mkfs.minix.c:571
#, c-format
msgid ""
"Maxsize=%zu\n"
"\n"
msgstr ""
"最大尺寸=%zu\n"
"\n"

#: disk-utils/mkfs.minix.c:584
#, c-format
msgid "%s: seek failed during testing of blocks"
msgstr "%s：在测试块时定位失败"

#: disk-utils/mkfs.minix.c:591
#, c-format
msgid "Weird values in do_check: probably bugs\n"
msgstr "do_check 中的值异常：可能有 bug\n"

#: disk-utils/mkfs.minix.c:624
#, c-format
msgid "%s: seek failed in check_blocks"
msgstr "%s：在 check_blocks 中定位失败"

#: disk-utils/mkfs.minix.c:634
#, c-format
msgid "%s: bad blocks before data-area: cannot make fs"
msgstr "%s：数据区前有坏块：无法创建文件系统"

#: disk-utils/mkfs.minix.c:641 disk-utils/mkfs.minix.c:665
#, c-format
msgid "%d bad block\n"
msgid_plural "%d bad blocks\n"
msgstr[0] "%d 个坏块\n"

#: disk-utils/mkfs.minix.c:650
#, c-format
msgid "%s: can't open file of bad blocks"
msgstr "%s: 打不开坏块文件"

#: disk-utils/mkfs.minix.c:655
#, c-format
msgid "badblock number input error on line %d\n"
msgstr "第 %d 行坏块数输入错误\n"

#: disk-utils/mkfs.minix.c:656
#, c-format
msgid "%s: cannot read badblocks file"
msgstr "%s: 打不开 badblocks 文件"

#: disk-utils/mkfs.minix.c:696
#, c-format
msgid "block size smaller than physical sector size of %s"
msgstr "块尺寸比 %s 的物理扇区尺寸小"

#: disk-utils/mkfs.minix.c:699
#, c-format
msgid "cannot determine size of %s"
msgstr "无法确定 %s 的大小"

#: disk-utils/mkfs.minix.c:707
#, c-format
msgid "%s: requested blocks (%llu) exceeds available (%llu) blocks\n"
msgstr "%s：重复的块 (%llu) 超出可用的 (%llu) 块\n"

#: disk-utils/mkfs.minix.c:710
#, c-format
msgid "%s: number of blocks too small"
msgstr "%s：块数太小"

#: disk-utils/mkfs.minix.c:725 disk-utils/mkfs.minix.c:731
#, c-format
msgid "unsupported name length: %d"
msgstr "不支持的名字长度：%d"

#: disk-utils/mkfs.minix.c:734
#, c-format
msgid "unsupported minix file system version: %d"
msgstr " 不支持的 minix 文件系统版本：%d"

#: disk-utils/mkfs.minix.c:771
msgid "-v is ambiguous, use '-2' instead"
msgstr "-v 含义不清，请转用“-2”"

#: disk-utils/mkfs.minix.c:782
msgid "failed to parse maximum length of filenames"
msgstr "解析文件名最大长度失败"

#: disk-utils/mkfs.minix.c:786
msgid "failed to parse number of inodes"
msgstr "解析 inode 数 失败"

#: disk-utils/mkfs.minix.c:810
msgid "failed to parse number of blocks"
msgstr "解析块数失败"

#: disk-utils/mkfs.minix.c:818
#, c-format
msgid "%s is mounted; will not make a filesystem here!"
msgstr "%s 已挂载；将不会在此创建文件系统！"

#: disk-utils/mkswap.c:80
#, c-format
msgid "Bad user-specified page size %u"
msgstr "用户指定的页大小 %u 有误"

#: disk-utils/mkswap.c:83
#, c-format
msgid "Using user-specified page size %d, instead of the system value %d"
msgstr "将使用用户指定的页大小 %d 来取代系统值 %d"

#: disk-utils/mkswap.c:124
msgid "Label was truncated."
msgstr "标签已截短。"

#: disk-utils/mkswap.c:132
#, c-format
msgid "no label, "
msgstr "无标签，"

#: disk-utils/mkswap.c:140
#, c-format
msgid "no uuid\n"
msgstr "无 uuid\n"

#: disk-utils/mkswap.c:148
#, c-format
msgid ""
"\n"
"Usage:\n"
" %s [options] device [size]\n"
msgstr ""
"\n"
"用法\n"
" %s [选项] 设备 [大小]\n"

#: disk-utils/mkswap.c:153
msgid "Set up a Linux swap area.\n"
msgstr "设置 Linux 交换区。\n"

#: disk-utils/mkswap.c:156
#, fuzzy, c-format
msgid ""
"\n"
"Options:\n"
" -c, --check               check bad blocks before creating the swap area\n"
" -f, --force               allow swap size area be larger than device\n"
" -p, --pagesize SIZE       specify page size in bytes\n"
" -L, --label LABEL         specify label\n"
" -v, --swapversion NUM     specify swap-space version number\n"
" -U, --uuid UUID           specify the uuid to use\n"
msgstr ""
"\n"
"选项：\n"
" -c, --check               创建交换区前检查坏块\n"
" -f, --force               允许交换区大于设备大小\n"
" -p, --pagesize SIZE       指定页大小为 SIZE 字节\n"
" -L, --label LABEL         指定标签为 LABEL\n"
" -v, --swapversion NUM     指定交换空间版本号为 NUM\n"
" -U, --uuid UUID           指定要使用的 UUID\n"
" -V, --version             输出版本信息并退出\n"
" -h, --help                显示此帮助并退出\n"
"\n"

#: disk-utils/mkswap.c:176
#, c-format
msgid "too many bad pages: %lu"
msgstr "坏页过多：%lu"

#: disk-utils/mkswap.c:197
msgid "seek failed in check_blocks"
msgstr "check_blocks (检查块)时定位失败"

#: disk-utils/mkswap.c:205
#, c-format
msgid "%lu bad page\n"
msgid_plural "%lu bad pages\n"
msgstr[0] "%lu 个坏页\n"

#: disk-utils/mkswap.c:230
msgid "unable to alloc new libblkid probe"
msgstr "无法分配新的 libblkid 探针"

#: disk-utils/mkswap.c:232
msgid "unable to assign device to libblkid probe"
msgstr "无法将设备分配给 libblkid 探针"

#: disk-utils/mkswap.c:249
#, c-format
msgid "warning: checking bad blocks from swap file is not supported: %s"
msgstr "警告：不支持检查交换区的坏块：%s"

#: disk-utils/mkswap.c:263 disk-utils/mkswap.c:289 disk-utils/mkswap.c:336
msgid "unable to rewind swap-device"
msgstr "无法倒回(rewind)交换设备"

#: disk-utils/mkswap.c:292
msgid "unable to erase bootbits sectors"
msgstr "不能擦除 bootbits 扇区"

#: disk-utils/mkswap.c:308
#, c-format
msgid "%s: warning: wiping old %s signature."
msgstr "%s：警告，将擦除旧的 %s 签名。"

#: disk-utils/mkswap.c:313
#, c-format
msgid "%s: warning: don't erase bootbits sectors"
msgstr "%s：警告，不要擦除 bootbits 扇区"

#: disk-utils/mkswap.c:316
#, c-format
msgid "        (%s partition table detected). "
msgstr "        (检测到 %s 分区表)。"

#: disk-utils/mkswap.c:318
#, c-format
msgid "        (compiled without libblkid). "
msgstr "        (编译时未链接 libblkid)。"

#: disk-utils/mkswap.c:319
#, c-format
msgid "Use -f to force.\n"
msgstr "使用 -f 选项强制执行。\n"

#: disk-utils/mkswap.c:341
#, c-format
msgid "%s: unable to write signature page"
msgstr "%s：无法写签名页"

#: disk-utils/mkswap.c:382
msgid "parsing page size failed"
msgstr "解析页大小失败"

#: disk-utils/mkswap.c:388
msgid "parsing version number failed"
msgstr "解析版本号失败"

#: disk-utils/mkswap.c:391
#, c-format
msgid "swapspace version %d is not supported"
msgstr "不支持 swapspace 版本 %d"

#: disk-utils/mkswap.c:397
#, c-format
msgid "warning: ignoring -U (UUIDs are unsupported by %s)"
msgstr "警告：将忽略 -U 选项(%s 不支持 UUID)"

#: disk-utils/mkswap.c:416
msgid "only one device argument is currently supported"
msgstr "当前只支持一个设备参数"

#: disk-utils/mkswap.c:423
msgid "error: parsing UUID failed"
msgstr "错误：解析 UUID 失败"

#: disk-utils/mkswap.c:432
msgid "error: Nowhere to set up swap on?"
msgstr "错误：没有设置交换空间的地方？"

#: disk-utils/mkswap.c:438
msgid "invalid block count argument"
msgstr "无效的 块计数 参数"

#: disk-utils/mkswap.c:447
#, c-format
msgid "error: size %llu KiB is larger than device size %<PRIu64> KiB"
msgstr "错误：尺寸 %llu KiB 大于设备尺寸 %<PRIu64> KiB"

#: disk-utils/mkswap.c:453
#, c-format
msgid "error: swap area needs to be at least %ld KiB"
msgstr "错误：交换区至少需要 %ld KiB"

#: disk-utils/mkswap.c:458
#, c-format
msgid "warning: truncating swap area to %llu KiB"
msgstr "警告：将把交换区截短为 %llu KiB"

#: disk-utils/mkswap.c:463
#, c-format
msgid "error: %s is mounted; will not make swapspace"
msgstr "错误：%s 已挂载；将不会创建交换空间"

#: disk-utils/mkswap.c:470 sys-utils/swapon.c:529
#, c-format
msgid "%s: insecure permissions %04o, %04o suggested."
msgstr "%s：不安全的权限 %04o，建议使用 %04o。"

#: disk-utils/mkswap.c:474 sys-utils/swapon.c:534
#, c-format
msgid "%s: insecure file owner %d, 0 (root) suggested."
msgstr "%s：不安全的文件拥有者 %d，建议使用 0(root)。"

#: disk-utils/mkswap.c:489
msgid "Unable to set up swap-space: unreadable"
msgstr "无法设置交换空间：不可读"

#: disk-utils/mkswap.c:494
#, c-format
msgid "Setting up swapspace version %d, size = %s (%<PRIu64> bytes)\n"
msgstr "正在设置交换空间版本 %d，大小 = %s (%<PRIu64>  个字节)\n"

#: disk-utils/mkswap.c:514
#, c-format
msgid "%s: unable to obtain selinux file label"
msgstr "%s：无法获得 selinux 文件标签"

#: disk-utils/mkswap.c:517
msgid "unable to matchpathcon()"
msgstr "无法执行 matchpathcon()"

#: disk-utils/mkswap.c:520
msgid "unable to create new selinux context"
msgstr "无法创建新的 selinux 环境(context)"

#: disk-utils/mkswap.c:522
msgid "couldn't compute selinux context"
msgstr "无法计算 selinux 环境(context)"

#: disk-utils/mkswap.c:528
#, c-format
msgid "unable to relabel %s to %s"
msgstr "无法将 %s 标签改为 %s"

#: disk-utils/partx.c:86
msgid "partition number"
msgstr "分区号"

#: disk-utils/partx.c:87
msgid "start of the partition in sectors"
msgstr "分区起点(扇区数)"

#: disk-utils/partx.c:88
msgid "end of the partition in sectors"
msgstr "分区终点(扇区数)"

#: disk-utils/partx.c:89
msgid "number of sectors"
msgstr "扇区数"

#: disk-utils/partx.c:90
msgid "human readable size"
msgstr "易读形式的大小"

#: disk-utils/partx.c:91
msgid "partition name"
msgstr "分区名"

#: disk-utils/partx.c:92 misc-utils/findmnt.c:108 misc-utils/lsblk.c:173
msgid "partition UUID"
msgstr "分区 UUID"

#: disk-utils/partx.c:93
msgid "partition table type (dos, gpt, ...)"
msgstr "分区表类型(dos、gpt、...)"

#: disk-utils/partx.c:94 misc-utils/lsblk.c:174
msgid "partition flags"
msgstr "分区标志"

#: disk-utils/partx.c:95
msgid "partition type (a string, a UUID, or hex)"
msgstr "分区类型(字符串，UUID 或十六进制数)"

#: disk-utils/partx.c:114 sys-utils/losetup.c:521 sys-utils/losetup.c:630
msgid "failed to initialize loopcxt"
msgstr "初始化 loopcxt 失败"

#: disk-utils/partx.c:118
#, c-format
msgid "%s: failed to find unused loop device"
msgstr "%s：查找未使用的回环设备失败"

#: disk-utils/partx.c:122
#, c-format
msgid "Trying to use '%s' for the loop device\n"
msgstr "尝试将“%s”用作回环设备\n"

#: disk-utils/partx.c:126
#, c-format
msgid "%s: failed to set backing file"
msgstr "%s：设置后备文件失败"

#: disk-utils/partx.c:131 sys-utils/losetup.c:565
#, c-format
msgid "%s: failed to set up loop device"
msgstr "%s：设置回环设备失败"

#: disk-utils/partx.c:161 login-utils/lslogins.c:307 misc-utils/fincore.c:92
#: misc-utils/findmnt.c:376 misc-utils/lsblk.c:367 misc-utils/lslocks.c:342
#: misc-utils/uuidparse.c:125 misc-utils/wipefs.c:126 sys-utils/losetup.c:110
#: sys-utils/lscpu.c:220 sys-utils/lsipc.c:232 sys-utils/lsmem.c:180
#: sys-utils/lsns.c:223 sys-utils/prlimit.c:277 sys-utils/rfkill.c:160
#: sys-utils/swapon.c:150 sys-utils/wdctl.c:151 sys-utils/zramctl.c:146
#, c-format
msgid "unknown column: %s"
msgstr "未知列: %s"

#: disk-utils/partx.c:208
#, c-format
msgid "%s: failed to get partition number"
msgstr "%s：获取分区号失败"

#: disk-utils/partx.c:286 disk-utils/partx.c:324 disk-utils/partx.c:477
#, c-format
msgid "specified range <%d:%d> does not make sense"
msgstr "指定的范围 <%d:%d> 无效"

#: disk-utils/partx.c:290
#, c-format
msgid "range recount: max partno=%d, lower=%d, upper=%d\n"
msgstr "重新计算范围：最大分区号=%d，下限=%d，上限=%d\n"

#: disk-utils/partx.c:297
#, c-format
msgid "%s: error deleting partition %d"
msgstr "%s：删除分区 %d 出错"

#: disk-utils/partx.c:299
#, c-format
msgid "%s: error deleting partitions %d-%d"
msgstr "%s：删除分区 %d-%d 出错"

#: disk-utils/partx.c:333
#, c-format
msgid "%s: partition #%d removed\n"
msgstr "%s：分区 #%d 已移除\n"

#: disk-utils/partx.c:337
#, c-format
msgid "%s: partition #%d doesn't exist\n"
msgstr "%s：分区 #%d 不存在\n"

#: disk-utils/partx.c:342
#, c-format
msgid "%s: deleting partition #%d failed"
msgstr "%s：删除分区 #%d 失败"

#: disk-utils/partx.c:362
#, c-format
msgid "%s: error adding partition %d"
msgstr "%s：添加分区 %d 出错"

#: disk-utils/partx.c:364
#, c-format
msgid "%s: error adding partitions %d-%d"
msgstr "%s：添加分区 %d-%d 出错"

#: disk-utils/partx.c:405 disk-utils/partx.c:513
#, c-format
msgid "%s: partition #%d added\n"
msgstr "%s：分区 #%d 已添加\n"

#: disk-utils/partx.c:410
#, c-format
msgid "%s: adding partition #%d failed"
msgstr "%s：添加分区 #%d 失败"

#: disk-utils/partx.c:445
#, c-format
msgid "%s: error updating partition %d"
msgstr "%s：更新分区 %d 出错"

#: disk-utils/partx.c:447
#, c-format
msgid "%s: error updating partitions %d-%d"
msgstr "%s：更新分区 %d-%d 出错"

#: disk-utils/partx.c:486
#, c-format
msgid "%s: no partition #%d"
msgstr "%s：无分区 #%d"

#: disk-utils/partx.c:507
#, c-format
msgid "%s: partition #%d resized\n"
msgstr "%s：已调整分区 #%d 的大小\n"

#: disk-utils/partx.c:521
#, c-format
msgid "%s: updating partition #%d failed"
msgstr "%s：更新分区 #%d 失败"

#: disk-utils/partx.c:562
#, c-format
msgid "#%2d: %9ju-%9ju (%9ju sector, %6ju MB)\n"
msgid_plural "#%2d: %9ju-%9ju (%9ju sectors, %6ju MB)\n"
msgstr[0] "#%2d：%9ju-%9ju (%9ju 扇区%6ju MB)\n"

#: disk-utils/partx.c:678 misc-utils/fincore.c:373 misc-utils/findmnt.c:1622
#: misc-utils/lsblk.c:1930 misc-utils/lslocks.c:462 sys-utils/losetup.c:333
#: sys-utils/lscpu.c:1618 sys-utils/prlimit.c:306 sys-utils/rfkill.c:467
#: sys-utils/swapon.c:293 sys-utils/wdctl.c:271
#, fuzzy
msgid "failed to allocate output column"
msgstr "分配输出行失败"

#: disk-utils/partx.c:722
#, c-format
msgid "failed to initialize blkid filter for '%s'"
msgstr "初始化“%s”的 blkid 过滤器失败"

#: disk-utils/partx.c:730
#, c-format
msgid "%s: failed to read partition table"
msgstr "%s：读取分区表失败"

#: disk-utils/partx.c:736
#, c-format
msgid "%s: partition table type '%s' detected\n"
msgstr "%s：检测到分区表类型“%s”\n"

#: disk-utils/partx.c:740
#, c-format
msgid "%s: partition table with no partitions"
msgstr "%s：分区表中无分区"

#: disk-utils/partx.c:753
#, c-format
msgid " %s [-a|-d|-s|-u] [--nr <n:m> | <partition>] <disk>\n"
msgstr " %s [-a|-d|-s|-u] [--nr <n:m> | <分区>] <磁盘>\n"

#: disk-utils/partx.c:757
msgid "Tell the kernel about the presence and numbering of partitions.\n"
msgstr "告知内核分区的存在和排列情况。\n"

#: disk-utils/partx.c:760
msgid " -a, --add            add specified partitions or all of them\n"
msgstr " -a, --add            添加指定的分区或所有分区\n"

#: disk-utils/partx.c:761
msgid " -d, --delete         delete specified partitions or all of them\n"
msgstr " -d, --delete         删除指定的分区或所有分区\n"

#: disk-utils/partx.c:762
msgid " -u, --update         update specified partitions or all of them\n"
msgstr " -u, --update         更新指定的分区或所有分区\n"

#: disk-utils/partx.c:763
msgid ""
" -s, --show           list partitions\n"
"\n"
msgstr ""
" -s, --show           列出分区\n"
"\n"

#: disk-utils/partx.c:764 misc-utils/lsblk.c:1640 sys-utils/lsmem.c:505
msgid " -b, --bytes          print SIZE in bytes rather than in human readable format\n"
msgstr " -b, --bytes          以字节为单位而非易读的格式来打印 SIZE\n"

#: disk-utils/partx.c:765
msgid " -g, --noheadings     don't print headings for --show\n"
msgstr " -g, --noheadings     --show 时不打印标题\n"

#: disk-utils/partx.c:766
msgid " -n, --nr <n:m>       specify the range of partitions (e.g. --nr 2:4)\n"
msgstr " -n, --nr <n:m>       指定分区范围(例如：--nr 2:4)\n"

#: disk-utils/partx.c:767
msgid " -o, --output <list>  define which output columns to use\n"
msgstr " -o, --output <列表>  定义使用哪个输出列\n"

#: disk-utils/partx.c:768 misc-utils/lsblk.c:1656 sys-utils/lsmem.c:503
msgid " -P, --pairs          use key=\"value\" output format\n"
msgstr " -P, --pairs          使用 key=“value” 输出格式\n"

#: disk-utils/partx.c:769 misc-utils/lsblk.c:1657 sys-utils/lsmem.c:508
msgid " -r, --raw            use raw output format\n"
msgstr " -r, --raw            使用原生输出格式\n"

#: disk-utils/partx.c:770
#, fuzzy
msgid " -S, --sector-size <num>  overwrite sector size\n"
msgstr " -b, --sectors-size <大小>     显示扇区计数和大小\n"

#: disk-utils/partx.c:771
#, fuzzy
msgid " -t, --type <type>    specify the partition type\n"
msgstr " -t, --type <类型>    指定分区类型(dos、bsd、solaris 等)\n"

#: disk-utils/partx.c:772
#, fuzzy
msgid "     --list-types     list supported partition types and exit\n"
msgstr "     --list               列出可设置的架构并退出\n"

#: disk-utils/partx.c:773 sys-utils/fallocate.c:101
msgid " -v, --verbose        verbose mode\n"
msgstr " -v, --verbose        详尽模式\n"

#: disk-utils/partx.c:856
msgid "failed to parse --nr <M-N> range"
msgstr "解析 --nr <M-N> 范围失败"

#: disk-utils/partx.c:942
msgid "partition and disk name do not match"
msgstr "分区和磁盘名不符"

#: disk-utils/partx.c:971
msgid "--nr and <partition> are mutually exclusive"
msgstr "--nr 和 <分区> 相互排斥"

#: disk-utils/partx.c:990
#, c-format
msgid "partition: %s, disk: %s, lower: %d, upper: %d\n"
msgstr "分区：%s，磁盘：%s，从分区：%d,到分区：%d\n"

#: disk-utils/partx.c:1002
#, c-format
msgid "%s: cannot delete partitions"
msgstr "%s：不能删除分区"

#: disk-utils/partx.c:1005
#, c-format
msgid "%s: partitioned loop devices unsupported"
msgstr "%s：不支持已分区的回环设备"

#: disk-utils/partx.c:1022
#, c-format
msgid "%s: failed to initialize blkid prober"
msgstr "%s：初始化 blkid 探针失败"

#: disk-utils/raw.c:50
#, c-format
msgid ""
" %1$s %2$srawN <major> <minor>\n"
" %1$s %2$srawN /dev/<blockdevice>\n"
" %1$s -q %2$srawN\n"
" %1$s -qa\n"
msgstr ""
" %1$s %2$srawN <主设备号> <次设备号>\n"
" %1$s %2$srawN /dev/<块设备>\n"
" %1$s -q %2$srawN\n"
" %1$s -qa\n"

#: disk-utils/raw.c:57
msgid "Bind a raw character device to a block device.\n"
msgstr "将原生字符设备绑定到块设备。\n"

#: disk-utils/raw.c:60
msgid " -q, --query    set query mode\n"
msgstr " -q, --query    设置查询模式\n"

#: disk-utils/raw.c:61
msgid " -a, --all      query all raw devices\n"
msgstr " -a, --all      查询所有 raw 设备\n"

#: disk-utils/raw.c:167
#, c-format
msgid "Device '%s' is the control raw device (use raw<N> where <N> is greater than zero)"
msgstr "设备“%s”是控制原生设备(请使用 raw<N>，其中 <N> 大于 0)"

#: disk-utils/raw.c:184
#, c-format
msgid "Cannot locate block device '%s'"
msgstr "无法定位块设备“%s”"

#: disk-utils/raw.c:187
#, c-format
msgid "Device '%s' is not a block device"
msgstr "设备“%s”不是块设备"

#: disk-utils/raw.c:196 disk-utils/raw.c:199 sys-utils/ipcrm.c:352
#: sys-utils/ipcrm.c:366 sys-utils/ipcrm.c:380
msgid "failed to parse argument"
msgstr "解析参数失败"

#: disk-utils/raw.c:217
#, c-format
msgid "Cannot open master raw device '%s'"
msgstr "无法打开主 Raw 设备“%s”"

#: disk-utils/raw.c:232
#, c-format
msgid "Cannot locate raw device '%s'"
msgstr "无法定位 raw 设备“%s”"

#: disk-utils/raw.c:235
#, c-format
msgid "Raw device '%s' is not a character dev"
msgstr "设备“%s”不是字符设备"

#: disk-utils/raw.c:239
#, c-format
msgid "Device '%s' is not a raw dev"
msgstr "设备“%s”不是 raw 设备"

#: disk-utils/raw.c:249
msgid "Error querying raw device"
msgstr "查询原生(raw)设备失败"

#: disk-utils/raw.c:258 disk-utils/raw.c:273
#, c-format
msgid "%sraw%d:  bound to major %d, minor %d\n"
msgstr "%sraw%d：绑定到主设备号 %d, 次设备号 %d\n"

#: disk-utils/raw.c:272
msgid "Error setting raw device"
msgstr "设置原生(raw)设备出错"

#: disk-utils/resizepart.c:20
#, c-format
msgid " %s <disk device> <partition number> <length>\n"
msgstr " %s <磁盘设备> <分区号> <长度>\n"

#: disk-utils/resizepart.c:24
msgid "Tell the kernel about the new size of a partition.\n"
msgstr "告诉内核分区的新尺寸。\n"

#: disk-utils/resizepart.c:106
#, c-format
msgid "%s: failed to get start of the partition number %s"
msgstr "%s：获取分区号 %s 的起点失败"

#: disk-utils/resizepart.c:111
msgid "failed to resize partition"
msgstr "调整分区大小失败"

#: disk-utils/sfdisk.c:232
msgid "failed to allocate nested libfdisk context"
msgstr "分配嵌套 libfdisk 环境(context)失败"

#: disk-utils/sfdisk.c:292
#, c-format
msgid "cannot seek %s"
msgstr "无法定位 %s"

#: disk-utils/sfdisk.c:303 libfdisk/src/bsd.c:722 libfdisk/src/bsd.c:896
#, c-format
msgid "cannot write %s"
msgstr "无法写 %s"

#: disk-utils/sfdisk.c:310
#, c-format
msgid "%12s (offset %5ju, size %5ju): %s"
msgstr "%12s (偏移  %5ju, 大小 %5ju): %s"

#: disk-utils/sfdisk.c:316
#, c-format
msgid "%s: failed to create a backup"
msgstr "%s：创建备份失败"

#: disk-utils/sfdisk.c:329
msgid "failed to create a backup file, $HOME undefined"
msgstr "创建备份失败，未定义 $HOME"

#: disk-utils/sfdisk.c:355
msgid "Backup files:"
msgstr "备份文件："

#: disk-utils/sfdisk.c:380
msgid "failed to read new partition from device; ignoring --move-data"
msgstr "从设备读取新分区失败；将忽略 --move-data"

#: disk-utils/sfdisk.c:382
msgid "failed to get size of the new partition; ignoring --move-data"
msgstr "获取新分区大小失败，将忽略 --move-data"

#: disk-utils/sfdisk.c:384
msgid "failed to get start of the new partition; ignoring --move-data"
msgstr "获取新分区起点失败，将忽略 --move-data"

#: disk-utils/sfdisk.c:386
msgid "failed to get size of the old partition; ignoring --move-data"
msgstr "获取新分区大小失败，将忽略 --move-data"

#: disk-utils/sfdisk.c:388
msgid "failed to get start of the old partition; ignoring --move-data"
msgstr "获取旧分区起点失败，将忽略 --move-data"

#: disk-utils/sfdisk.c:390
msgid "start of the partition has not been moved; ignoring --move-data"
msgstr "分区起点未移动；将忽略 --move-data"

#: disk-utils/sfdisk.c:392
msgid "new partition is smaller than original; ignoring --move-data"
msgstr "新分区小于原分区；将忽略 --move-data"

#: disk-utils/sfdisk.c:442
msgid "Data move:"
msgstr "数据移动︰"

#: disk-utils/sfdisk.c:444
#, c-format
msgid " typescript file: %s"
msgstr "typescript 文件：%s"

#: disk-utils/sfdisk.c:445
#, c-format
msgid " old start: %ju, new start: %ju (move %ju sectors)\n"
msgstr " 原起点：%ju，新起点：%ju (移动 %ju 个扇区)\n"

#: disk-utils/sfdisk.c:452
msgid "Do you want to move partition data?"
msgstr "您想移动分区数据吗？"

#: disk-utils/sfdisk.c:454 disk-utils/sfdisk.c:1814
msgid "Leaving."
msgstr "离开中。"

#: disk-utils/sfdisk.c:527
#, c-format
msgid "%s: failed to move data"
msgstr "%s：移动数据失败"

#: disk-utils/sfdisk.c:542
msgid "The partition table is unchanged (--no-act)."
msgstr "分区表未更改(--no-act)。"

#: disk-utils/sfdisk.c:548
msgid ""
"\n"
"The partition table has been altered."
msgstr ""
"\n"
"分区表已调整。"

#: disk-utils/sfdisk.c:631
#, c-format
msgid "unsupported label '%s'"
msgstr "不支持的标签：“%s”"

#: disk-utils/sfdisk.c:634
msgid ""
"Id  Name\n"
"\n"
msgstr ""
"Id 名称\n"
"\n"

#: disk-utils/sfdisk.c:664
msgid "unrecognized partition table type"
msgstr "未识别的分区表类型"

#: disk-utils/sfdisk.c:717
#, c-format
msgid "Cannot get size of %s"
msgstr "无法获得 %s 的大小"

#: disk-utils/sfdisk.c:754
#, c-format
msgid "total: %ju blocks\n"
msgstr "共计：%ju 个块\n"

#: disk-utils/sfdisk.c:816 disk-utils/sfdisk.c:894 disk-utils/sfdisk.c:935
#: disk-utils/sfdisk.c:965 disk-utils/sfdisk.c:1032 disk-utils/sfdisk.c:1096
#: disk-utils/sfdisk.c:1151 disk-utils/sfdisk.c:1207 disk-utils/sfdisk.c:1561
msgid "no disk device specified"
msgstr "未指定磁盘设备"

#: disk-utils/sfdisk.c:830
#, fuzzy
msgid "cannot switch to PMBR"
msgstr "无法 stat %s"

#: disk-utils/sfdisk.c:832
#, fuzzy
msgid "toggle boot flags is supported for MBR or PMBR only"
msgstr "开/关启动标志 只支持 MBR"

#: disk-utils/sfdisk.c:867 disk-utils/sfdisk.c:914 disk-utils/sfdisk.c:1037
#: disk-utils/sfdisk.c:1101 disk-utils/sfdisk.c:1156 disk-utils/sfdisk.c:1212
#: disk-utils/sfdisk.c:1559 disk-utils/sfdisk.c:2056
msgid "failed to parse partition number"
msgstr "解析分区号失败"

#: disk-utils/sfdisk.c:872
#, c-format
msgid "%s: partition %d: failed to toggle bootable flag"
msgstr "%s：分区 %d：开/关启动标志失败"

#: disk-utils/sfdisk.c:909 disk-utils/sfdisk.c:917
#, c-format
msgid "%s: partition %zu: failed to delete"
msgstr "%s：分区 %zu：删除失败"

#: disk-utils/sfdisk.c:972
#, fuzzy, c-format
msgid "%s: does not contain a recognized partition table"
msgstr "设备不包含可识别的分区表。"

#: disk-utils/sfdisk.c:976
msgid "failed to allocate dump struct"
msgstr "分配转储结构失败"

#: disk-utils/sfdisk.c:980
#, fuzzy, c-format
msgid "%s: failed to dump partition table"
msgstr "转储分区表失败"

#: disk-utils/sfdisk.c:1010
#, c-format
msgid "%s: no partition table found"
msgstr "%s：找不到分区表"

#: disk-utils/sfdisk.c:1014
#, c-format
msgid "%s: partition %zu: partition table contains only %zu partitions"
msgstr "%s：分区 %zu：分区表中只包含 %zu 个分区"

#: disk-utils/sfdisk.c:1017
#, c-format
msgid "%s: partition %zu: partition is unused"
msgstr "%s: 分区 %zu: 分区未使用"

#: disk-utils/sfdisk.c:1036 disk-utils/sfdisk.c:1100 disk-utils/sfdisk.c:1155
#: disk-utils/sfdisk.c:1211
msgid "no partition number specified"
msgstr "未指定分区号"

#: disk-utils/sfdisk.c:1042 disk-utils/sfdisk.c:1106 disk-utils/sfdisk.c:1161
#: disk-utils/sfdisk.c:1217
msgid "unexpected arguments"
msgstr "参数异常"

#: disk-utils/sfdisk.c:1057
#, c-format
msgid "%s: partition %zu: failed to get partition type"
msgstr "%s: 分区 %zu:获取分区类型失败"

#: disk-utils/sfdisk.c:1076
#, c-format
msgid "failed to parse %s partition type '%s'"
msgstr "解析 %s 的分区类型“%s”失败"

#: disk-utils/sfdisk.c:1080
#, c-format
msgid "%s: partition %zu: failed to set partition type"
msgstr "%s: 分区 %zu: 设置分区类型失败"

#: disk-utils/sfdisk.c:1118
#, c-format
msgid "%s: partition %zu: failed to get partition UUID"
msgstr "%s: 分区 %zu: 获取分区 UUID 失败"

#: disk-utils/sfdisk.c:1131 disk-utils/sfdisk.c:1186 disk-utils/sfdisk.c:1240
msgid "failed to allocate partition object"
msgstr "分配分区对象失败"

#: disk-utils/sfdisk.c:1135
#, c-format
msgid "%s: partition %zu: failed to set partition UUID"
msgstr "%s: 分区 %zu: 设置分区 UUID 失败"

#: disk-utils/sfdisk.c:1173
#, c-format
msgid "%s: partition %zu: failed to get partition name"
msgstr "%s: 分区 %zu: 获取分区名失败"

#: disk-utils/sfdisk.c:1190
#, c-format
msgid "%s: partition %zu: failed to set partition name"
msgstr "%s: 分区 %zu: 设置分区名失败"

#: disk-utils/sfdisk.c:1244
#, c-format
msgid "%s: partition %zu: failed to set partition attributes"
msgstr "%s: 分区 %zu: 设置分区属性失败"

#: disk-utils/sfdisk.c:1287
msgid " Commands:\n"
msgstr " 命令：\n"

#: disk-utils/sfdisk.c:1289
msgid "   write    write table to disk and exit\n"
msgstr "   write    将分区表写入磁盘并退出\n"

#: disk-utils/sfdisk.c:1290
msgid "   quit     show new situation and wait for user's feedback before write\n"
msgstr "   quit     显示新状况并等待用户反馈后再写入\n"

#: disk-utils/sfdisk.c:1291
msgid "   abort    exit sfdisk shell\n"
msgstr "   abort    退出 sfdisk shell\n"

#: disk-utils/sfdisk.c:1292
msgid "   print    display the partition table\n"
msgstr "   print    显示分区表\n"

#: disk-utils/sfdisk.c:1293
msgid "   help     show this help text\n"
msgstr "   help     显示帮助并退出\n"

#: disk-utils/sfdisk.c:1295
msgid "   Ctrl-D   the same as 'quit'\n"
msgstr "   Ctrl-D   同“quit”\n"

#: disk-utils/sfdisk.c:1299
msgid " Input format:\n"
msgstr " 输入格式：\n"

#: disk-utils/sfdisk.c:1301
msgid "   <start>, <size>, <type>, <bootable>\n"
msgstr "   <起点>, <大小>, <类型>, <可启动>\n"

#: disk-utils/sfdisk.c:1304
msgid ""
"   <start>  Beginning of the partition in sectors, or bytes if\n"
"            specified in the format <number>{K,M,G,T,P,E,Z,Y}.\n"
"            The default is the first free space.\n"
msgstr ""
"   <起点>   分区的起始扇区数或字节数，如果以\n"
"            <数值>{K,M,G,T,P,E,Z,Y} 格式指定。\n"
"            默认为第一处可用空间。\n"

#: disk-utils/sfdisk.c:1309
msgid ""
"   <size>   Size of the partition in sectors, or bytes if\n"
"            specified in the format <number>{K,M,G,T,P,E,Z,Y}.\n"
"            The default is all available space.\n"
msgstr ""
"   <大小>   分区的大小(扇区或字节数)，如果以\n"
"            <数值>{K,M,G,T,P,E,Z,Y} 格式指定。\n"
"            默认为所有可用空间。\n"

#: disk-utils/sfdisk.c:1314
msgid "   <type>   The partition type.  Default is a Linux data partition.\n"
msgstr "   <类型>   分区类型。默认为 Linux 数据分区。\n"

#: disk-utils/sfdisk.c:1315
#, fuzzy
msgid "            MBR: hex or L,S,E,X,U,R,V shortcuts.\n"
msgstr "            MBR：hex 或 L,S,E,X 快捷方式。\n"

#: disk-utils/sfdisk.c:1316
#, fuzzy
msgid "            GPT: UUID or L,S,H,U,R,V shortcuts.\n"
msgstr "            GPT：UUID 或 L,S,H 快捷方式。\n"

#: disk-utils/sfdisk.c:1319
msgid "   <bootable>  Use '*' to mark an MBR partition as bootable.\n"
msgstr "   <可启动>    使用“*”将 MBR 分区标记为 可启动。\n"

#: disk-utils/sfdisk.c:1323
msgid " Example:\n"
msgstr "示例：\n"

#: disk-utils/sfdisk.c:1325
msgid "   , 4G     Creates a 4GiB partition at default start offset.\n"
msgstr "   , 4G     在默认起始偏移位置创建一个 4GiB 分区。\n"

#: disk-utils/sfdisk.c:1357 sys-utils/dmesg.c:1539
msgid "unsupported command"
msgstr "不支持的命令"

#: disk-utils/sfdisk.c:1359
#, c-format
msgid "line %d: unsupported command"
msgstr "第 %d 行：不支持的命令"

#: disk-utils/sfdisk.c:1480
#, fuzzy, c-format
msgid "The old %s signature may remain on the device. It is recommended to wipe the device with wipefs(8) or sfdisk --wipe, in order to avoid possible collisions."
msgstr "强烈建议您使用 wipefs(8)来擦除该设备，以避免潜在的冲突。"

#: disk-utils/sfdisk.c:1528
msgid "failed to allocate partition name"
msgstr "分配分区名失败"

#: disk-utils/sfdisk.c:1569
msgid "failed to allocate script handler"
msgstr "分配脚本处理程序失败"

#: disk-utils/sfdisk.c:1585
#, c-format
msgid "%s: cannot modify partition %d: no partition table was found"
msgstr "%s：无法修改分区 %d：未找到分区表"

#: disk-utils/sfdisk.c:1590
#, c-format
msgid "%s: cannot modify partition %d: partition table contains only %zu partitions"
msgstr "%s: 无法修改分区 %d: 分区表只包含 %zu 个分区"

#: disk-utils/sfdisk.c:1596
#, c-format
msgid "warning: %s: partition %d is not defined yet"
msgstr "警告：%s: 分区 %d 尚未定义"

#: disk-utils/sfdisk.c:1614
#, c-format
msgid ""
"\n"
"Welcome to sfdisk (%s)."
msgstr ""
"\n"
"欢迎使用 sfdisk (%s)。"

#: disk-utils/sfdisk.c:1622
msgid "Checking that no-one is using this disk right now ..."
msgstr "请检查现在是不是有人在使用此磁盘..."

#: disk-utils/sfdisk.c:1625
msgid ""
" FAILED\n"
"\n"
msgstr ""
" 失败\n"
"\n"

#: disk-utils/sfdisk.c:1628
msgid ""
"This disk is currently in use - repartitioning is probably a bad idea.\n"
"Umount all file systems, and swapoff all swap partitions on this disk.\n"
"Use the --no-reread flag to suppress this check.\n"
msgstr ""
"该磁盘目前正在使用 - 不建议您重新分区。\n"
"请卸载此磁盘上所有的文件系统，并关闭(swapoff)上面的交换分区。\n"
"可使用 --no-reread 标志阻止此检查。\n"

#: disk-utils/sfdisk.c:1633
msgid "Use the --force flag to overrule all checks."
msgstr "使用 --force 标志否决所有检查。"

#: disk-utils/sfdisk.c:1635
msgid ""
" OK\n"
"\n"
msgstr ""
" 好的\n"
"\n"

#: disk-utils/sfdisk.c:1647
msgid ""
"\n"
"Old situation:"
msgstr ""
"\n"
"旧状况："

#: disk-utils/sfdisk.c:1665
#, c-format
msgid ""
"\n"
"sfdisk is going to create a new '%s' disk label.\n"
"Use 'label: <name>' before you define a first partition\n"
"to override the default."
msgstr ""
"\n"
"sfdisk 即将创建一个新的磁盘标签“%s”。\n"
"在定义第一个分区之前使用“label: <名字>”可覆盖默认值。"

#: disk-utils/sfdisk.c:1668
msgid ""
"\n"
"Type 'help' to get more information.\n"
msgstr ""
"\n"
"请执行“%s --help”了解更多信息。\n"

#: disk-utils/sfdisk.c:1686
msgid "All partitions used."
msgstr "所有分区均已使用。"

#: disk-utils/sfdisk.c:1714
msgid "Done.\n"
msgstr "完成。\n"

#: disk-utils/sfdisk.c:1726
msgid "Ignoring partition."
msgstr "忽略分区。"

#: disk-utils/sfdisk.c:1735 disk-utils/sfdisk.c:1795
msgid "Failed to apply script headers, disk label not created."
msgstr "无法应用脚本标头(header)，未创建磁盘标签。"

#: disk-utils/sfdisk.c:1754
#, fuzzy, c-format
msgid "Failed to add #%d partition"
msgstr "添加分区失败"

#: disk-utils/sfdisk.c:1777
msgid "Script header accepted."
msgstr "已接受脚本标头(header)。"

#: disk-utils/sfdisk.c:1802
msgid ""
"\n"
"New situation:"
msgstr ""
"\n"
"新状况："

#: disk-utils/sfdisk.c:1812
msgid "Do you want to write this to disk?"
msgstr "您想写入该磁盘吗？"

#: disk-utils/sfdisk.c:1825
msgid "Leaving.\n"
msgstr "离开中。\n"

#: disk-utils/sfdisk.c:1839
#, c-format
msgid ""
" %1$s [options] <dev> [[-N] <part>]\n"
" %1$s [options] <command>\n"
msgstr ""
" %1$s [选项] <设备> [[-N] <分区>]\n"
" %1$s [选项] <命令>\n"

#: disk-utils/sfdisk.c:1846
#, fuzzy
msgid " -A, --activate <dev> [<part> ...] list or set bootable (P)MBR partitions\n"
msgstr " -A, --activate <设备> [<分区> ...] 列出或设置可启动的 MBR 分区\n"

#: disk-utils/sfdisk.c:1847
msgid " -d, --dump <dev>                  dump partition table (usable for later input)\n"
msgstr " -d, --dump <设备>                 转储分区表(用于后续输入)\n"

#: disk-utils/sfdisk.c:1848
msgid " -J, --json <dev>                  dump partition table in JSON format\n"
msgstr " -J, --json <设备>                 以 JSON 格式转储分区表\n"

#: disk-utils/sfdisk.c:1849
msgid " -g, --show-geometry [<dev> ...]   list geometry of all or specified devices\n"
msgstr " -g, --show-geometry [<设备> ...]  列出所有或指定设备的几何属性\n"

#: disk-utils/sfdisk.c:1850
msgid " -l, --list [<dev> ...]            list partitions of each device\n"
msgstr " -l, --list [<设备> ...]           列出每台设备上的分区\n"

#: disk-utils/sfdisk.c:1851
msgid " -F, --list-free [<dev> ...]       list unpartitioned free areas of each device\n"
msgstr " -F, --list-free [<设备> ...]      列出每台设备上的未分区空间\n"

#: disk-utils/sfdisk.c:1852
msgid " -r, --reorder <dev>               fix partitions order (by start offset)\n"
msgstr " -r, --reorder <设备>              (通过起始偏移量)修复分区顺序\n"

#: disk-utils/sfdisk.c:1853
msgid " -s, --show-size [<dev> ...]       list sizes of all or specified devices\n"
msgstr " -s, --show-size [<设备> ...]       列出所有或指定设备的大小\n"

#: disk-utils/sfdisk.c:1854
msgid " -T, --list-types                  print the recognized types (see -X)\n"
msgstr " -T, --list-types                  打印识别的类型(见 -X)\n"

#: disk-utils/sfdisk.c:1855
msgid " -V, --verify [<dev> ...]          test whether partitions seem correct\n"
msgstr " -V, --verify [<设备> ...]         测试分区是否正确\n"

#: disk-utils/sfdisk.c:1856
msgid "     --delete <dev> [<part> ...]   delete all or specified partitions\n"
msgstr "     --delete <设备> [<分区> ...]  删除所有或指定分区\n"

#: disk-utils/sfdisk.c:1859
msgid " --part-label <dev> <part> [<str>] print or change partition label\n"
msgstr " --part-label <设备> <分区> [<字符串>] 打印或更改分区标签\n"

#: disk-utils/sfdisk.c:1860
msgid " --part-type <dev> <part> [<type>] print or change partition type\n"
msgstr " --part-type <设备> <分区> [<类型>]    打印或更改分区类型\n"

#: disk-utils/sfdisk.c:1861
msgid " --part-uuid <dev> <part> [<uuid>] print or change partition uuid\n"
msgstr " --part-uuid <设备> <分区> [<uuid>]    打印或更改分区 uuid\n"

#: disk-utils/sfdisk.c:1862
msgid " --part-attrs <dev> <part> [<str>] print or change partition attributes\n"
msgstr " --part-attrs <设备> <分区> [<字符串>] 打印或更改分区属性\n"

#: disk-utils/sfdisk.c:1865
msgid " <dev>                     device (usually disk) path\n"
msgstr " <设备>                    设备(通常是磁盘)的路径\n"

#: disk-utils/sfdisk.c:1866
msgid " <part>                    partition number\n"
msgstr " <分区>                   分区号\n"

#: disk-utils/sfdisk.c:1867
msgid " <type>                    partition type, GUID for GPT, hex for MBR\n"
msgstr " <类型>                    分区类型，GUID 对应 GPT，hex 对应 MBR\n"

#: disk-utils/sfdisk.c:1870
msgid " -a, --append              append partitions to existing partition table\n"
msgstr " -a, --append              将分区附加到已有分区表\n"

#: disk-utils/sfdisk.c:1871
msgid " -b, --backup              backup partition table sectors (see -O)\n"
msgstr " -b, --backup              备份分区表扇区(见 -O)\n"

#: disk-utils/sfdisk.c:1872
msgid "     --bytes               print SIZE in bytes rather than in human readable format\n"
msgstr "     -b, --bytes               以字节为单位而非易读的格式来打印 SIZE\n"

#: disk-utils/sfdisk.c:1873
msgid "     --move-data[=<typescript>] move partition data after relocation (requires -N)\n"
msgstr "     --move-data[=<typescript>] 重新定位后移动分区数据(需要 -N)\n"

#: disk-utils/sfdisk.c:1874
msgid " -f, --force               disable all consistency checking\n"
msgstr " -f, --force               禁用所有的一致性检查\n"

#: disk-utils/sfdisk.c:1875
msgid "     --color[=<when>]      colorize output (auto, always or never)\n"
msgstr "     --color[=<何时>]     彩色输出(auto，always 或 never)\n"

#: disk-utils/sfdisk.c:1878
msgid " -N, --partno <num>        specify partition number\n"
msgstr " -N, --partno <数字>       指定分区号\n"

#: disk-utils/sfdisk.c:1879
msgid " -n, --no-act              do everything except write to device\n"
msgstr " -n, --no-act              不真正执行写入设备\n"

#: disk-utils/sfdisk.c:1880
msgid "     --no-reread           do not check whether the device is in use\n"
msgstr "     --no-reread           不检查设备是否正在使用\n"

#: disk-utils/sfdisk.c:1881
msgid "     --no-tell-kernel      do not tell kernel about changes\n"
msgstr "     --no-tell-kernel      更改而不告诉内核\n"

#: disk-utils/sfdisk.c:1882
msgid " -O, --backup-file <path>  override default backup file name\n"
msgstr " -O, --backup-file <路径>  覆盖默认的备份文件名\n"

#: disk-utils/sfdisk.c:1883
msgid " -o, --output <list>       output columns\n"
msgstr " -o, --output <列表>       输出列\n"

#: disk-utils/sfdisk.c:1884
msgid " -q, --quiet               suppress extra info messages\n"
msgstr " -q, --quiet               禁止输出额外信息\n"

#: disk-utils/sfdisk.c:1885
msgid " -w, --wipe <mode>         wipe signatures (auto, always or never)\n"
msgstr " -w, --wipe <模式>         擦除签名(auto, always 或 never)\n"

#: disk-utils/sfdisk.c:1887
msgid " -X, --label <name>        specify label type (dos, gpt, ...)\n"
msgstr " -X, --label <名称>        指定标签类型(dos, gpt, ...)\n"

#: disk-utils/sfdisk.c:1888
msgid " -Y, --label-nested <name> specify nested label type (dos, bsd)\n"
msgstr " -Y, --label-nested <名称> 指定嵌套标签类型(dos, bsd)\n"

#: disk-utils/sfdisk.c:1890
msgid " -G, --show-pt-geometry    deprecated, alias to --show-geometry\n"
msgstr " -G, --show-pt-geometry    已废弃，同 --show-geometry\n"

#: disk-utils/sfdisk.c:1891
msgid " -L, --Linux               deprecated, only for backward compatibility\n"
msgstr " -L, --Linux               已废弃，仅为向后兼容\n"

#: disk-utils/sfdisk.c:1892
msgid " -u, --unit S              deprecated, only sector unit is supported\n"
msgstr " -u, --unit S              已废弃，只支持扇区单位\n"

#: disk-utils/sfdisk.c:2010
#, c-format
msgid "%s is deprecated in favour of --part-type"
msgstr "%s 已废弃，请改用 --part-type"

#: disk-utils/sfdisk.c:2015
msgid "--id is deprecated in favour of --part-type"
msgstr "--id 已废弃，请改用 --part-type"

#: disk-utils/sfdisk.c:2031
msgid "--show-pt-geometry is no more implemented. Using --show-geometry."
msgstr "--show-pt-geometry 不再实现。请使用 --show-geometry。"

#: disk-utils/sfdisk.c:2043
msgid "--Linux option is unnecessary and deprecated"
msgstr "--Linux 选项没必要，并且已废弃"

#: disk-utils/sfdisk.c:2072
#, c-format
msgid "unsupported unit '%c'"
msgstr "不支持的单位“%c”"

#: disk-utils/sfdisk.c:2075 include/c.h:336
#, c-format
msgid "%s from %s\n"
msgstr "%s，来自 %s\n"

#: disk-utils/sfdisk.c:2152
msgid "--movedata requires -N"
msgstr "--movedata  需要 -N"

#: disk-utils/swaplabel.c:74
#, c-format
msgid "failed to parse UUID: %s"
msgstr "解析 UUID 失败：%s"

#: disk-utils/swaplabel.c:78
#, c-format
msgid "%s: failed to seek to swap UUID"
msgstr "%s：定位到交换区 UUID 失败"

#: disk-utils/swaplabel.c:82
#, c-format
msgid "%s: failed to write UUID"
msgstr "%s：写 UUID 失败"

#: disk-utils/swaplabel.c:93
#, c-format
msgid "%s: failed to seek to swap label "
msgstr "%s：无法定位到交换区标签 "

#: disk-utils/swaplabel.c:100
#, c-format
msgid "label is too long. Truncating it to '%s'"
msgstr "标签过长。将截短到“%s”"

#: disk-utils/swaplabel.c:103
#, c-format
msgid "%s: failed to write label"
msgstr "%s：写标签失败"

#: disk-utils/swaplabel.c:127
msgid "Display or change the label or UUID of a swap area.\n"
msgstr "显示或更改交换区的标签或 UUID。\n"

#: disk-utils/swaplabel.c:130
msgid ""
" -L, --label <label> specify a new label\n"
" -U, --uuid <uuid>   specify a new uuid\n"
msgstr ""
" -L, --label <标签>  指定一个新标签\n"
" -U, --uuid <uuid>   指定一个新 uuid\n"

#: disk-utils/swaplabel.c:172
msgid "ignore -U (UUIDs are unsupported)"
msgstr "忽略 -U (不支持 UUID)"

#: include/c.h:214
#, fuzzy, c-format
msgid "Try '%s --help' for more information.\n"
msgstr "请尝试执行“%s --help”了解更多信息。\n"

#: include/c.h:318
msgid ""
"\n"
"Usage:\n"
msgstr ""
"\n"
"用法：\n"

#: include/c.h:319
msgid ""
"\n"
"Options:\n"
msgstr ""
"\n"
"选项：\n"

#: include/c.h:320
msgid ""
"\n"
"Functions:\n"
msgstr ""
"\n"
"功能：\n"

#: include/c.h:321
msgid ""
"\n"
"Commands:\n"
msgstr ""
"\n"
"命令：\n"

#: include/c.h:322
#, fuzzy
msgid ""
"\n"
"Available output columns:\n"
msgstr ""
"\n"
"可用的 --list 列：\n"

#: include/c.h:325
#, fuzzy
msgid "display this help"
msgstr " -?         显示此帮助并退出\n"

#: include/c.h:326
#, fuzzy
msgid "display version"
msgstr " -version\n"

#: include/c.h:334
#, c-format
msgid ""
"\n"
"For more details see %s.\n"
msgstr ""
"\n"
"更多信息请参阅 %s。\n"

#: include/closestream.h:46 include/closestream.h:48 login-utils/vipw.c:276
#: login-utils/vipw.c:295 sys-utils/rtcwake.c:298 term-utils/setterm.c:811
#: text-utils/col.c:160
msgid "write error"
msgstr "写出错"

#: include/colors.h:27
msgid "colors are enabled by default"
msgstr "默认启用颜色"

#: include/colors.h:29
msgid "colors are disabled by default"
msgstr "默认禁用颜色"

#: include/env.h:18 lib/pager.c:151 login-utils/login.c:1026
#: login-utils/login.c:1030 term-utils/agetty.c:1169
#, c-format
msgid "failed to set the %s environment variable"
msgstr "设置环境变量 %s 失败"

#: include/optutils.h:85
#, fuzzy, c-format
msgid "%s: mutually exclusive arguments:"
msgstr "相互排斥。"

#: include/pt-mbr-partnames.h:1
msgid "Empty"
msgstr "空"

#: include/pt-mbr-partnames.h:2
msgid "FAT12"
msgstr "FAT12"

#: include/pt-mbr-partnames.h:3
msgid "XENIX root"
msgstr "XENIX root"

#: include/pt-mbr-partnames.h:4
msgid "XENIX usr"
msgstr "XENIX usr"

#: include/pt-mbr-partnames.h:5
msgid "FAT16 <32M"
msgstr "FAT16 <32M"

#: include/pt-mbr-partnames.h:6
msgid "Extended"
msgstr "扩展"

#: include/pt-mbr-partnames.h:7
msgid "FAT16"
msgstr "FAT16"

#: include/pt-mbr-partnames.h:8
msgid "HPFS/NTFS/exFAT"
msgstr "HPFS/NTFS/exFAT"

#: include/pt-mbr-partnames.h:9
msgid "AIX"
msgstr "AIX"

#: include/pt-mbr-partnames.h:10
msgid "AIX bootable"
msgstr "AIX 可启动"

#: include/pt-mbr-partnames.h:11
msgid "OS/2 Boot Manager"
msgstr "OS/2 启动管理器"

#: include/pt-mbr-partnames.h:12
msgid "W95 FAT32"
msgstr "W95 FAT32"

#: include/pt-mbr-partnames.h:13
msgid "W95 FAT32 (LBA)"
msgstr "W95 FAT32 (LBA)"

#: include/pt-mbr-partnames.h:14
msgid "W95 FAT16 (LBA)"
msgstr "W95 FAT16 (LBA)"

#: include/pt-mbr-partnames.h:15
msgid "W95 Ext'd (LBA)"
msgstr "W95 扩展 (LBA)"

#: include/pt-mbr-partnames.h:16
msgid "OPUS"
msgstr "OPUS"

#: include/pt-mbr-partnames.h:17
msgid "Hidden FAT12"
msgstr "隐藏的 FAT12"

#: include/pt-mbr-partnames.h:18
msgid "Compaq diagnostics"
msgstr "Compaq 诊断"

#: include/pt-mbr-partnames.h:19
msgid "Hidden FAT16 <32M"
msgstr "隐藏的 FAT16 <32M"

#: include/pt-mbr-partnames.h:20
msgid "Hidden FAT16"
msgstr "隐藏的 FAT16"

#: include/pt-mbr-partnames.h:21
msgid "Hidden HPFS/NTFS"
msgstr "隐藏的 HPFS/NTFS"

#: include/pt-mbr-partnames.h:22
msgid "AST SmartSleep"
msgstr "AST 智能睡眠"

#: include/pt-mbr-partnames.h:23
msgid "Hidden W95 FAT32"
msgstr "隐藏的 W95 FAT32"

#: include/pt-mbr-partnames.h:24
msgid "Hidden W95 FAT32 (LBA)"
msgstr "隐藏的 W95 FAT32 (LBA)"

#: include/pt-mbr-partnames.h:25
msgid "Hidden W95 FAT16 (LBA)"
msgstr "隐藏的 W95 FAT16 (LBA)"

#: include/pt-mbr-partnames.h:26
msgid "NEC DOS"
msgstr "NEC DOS"

#: include/pt-mbr-partnames.h:27
msgid "Hidden NTFS WinRE"
msgstr "隐藏的 NTFS WinRE"

#: include/pt-mbr-partnames.h:28
msgid "Plan 9"
msgstr "Plan 9"

#: include/pt-mbr-partnames.h:29
msgid "PartitionMagic recovery"
msgstr "PartitionMagic 恢复"

#: include/pt-mbr-partnames.h:30
msgid "Venix 80286"
msgstr "Venix 80286"

#: include/pt-mbr-partnames.h:31
msgid "PPC PReP Boot"
msgstr "PPC PReP Boot"

#: include/pt-mbr-partnames.h:32
msgid "SFS"
msgstr "SFS"

#: include/pt-mbr-partnames.h:33
msgid "QNX4.x"
msgstr "QNX4.x"

#: include/pt-mbr-partnames.h:34
msgid "QNX4.x 2nd part"
msgstr "QNX4.x 第2部分"

#: include/pt-mbr-partnames.h:35
msgid "QNX4.x 3rd part"
msgstr "QNX4.x 第3部分"

#: include/pt-mbr-partnames.h:36
msgid "OnTrack DM"
msgstr "OnTrack DM"

#: include/pt-mbr-partnames.h:37
msgid "OnTrack DM6 Aux1"
msgstr "OnTrack DM6 Aux1"

#: include/pt-mbr-partnames.h:38
msgid "CP/M"
msgstr "CP/M"

#: include/pt-mbr-partnames.h:39
msgid "OnTrack DM6 Aux3"
msgstr "OnTrack DM6 Aux3"

#: include/pt-mbr-partnames.h:40
msgid "OnTrackDM6"
msgstr "OnTrackDM6"

#: include/pt-mbr-partnames.h:41
msgid "EZ-Drive"
msgstr "EZ-Drive"

#: include/pt-mbr-partnames.h:42
msgid "Golden Bow"
msgstr "Golden Bow"

#: include/pt-mbr-partnames.h:43
msgid "Priam Edisk"
msgstr "Priam Edisk"

#: include/pt-mbr-partnames.h:44 include/pt-mbr-partnames.h:91
#: include/pt-mbr-partnames.h:98 include/pt-mbr-partnames.h:99
msgid "SpeedStor"
msgstr "SpeedStor"

#: include/pt-mbr-partnames.h:45
msgid "GNU HURD or SysV"
msgstr "GNU HURD 或 SysV"

#: include/pt-mbr-partnames.h:46
msgid "Novell Netware 286"
msgstr "Novell Netware 286"

#: include/pt-mbr-partnames.h:47
msgid "Novell Netware 386"
msgstr "Novell Netware 386"

#: include/pt-mbr-partnames.h:48
msgid "DiskSecure Multi-Boot"
msgstr "DiskSecure 多启动"

#: include/pt-mbr-partnames.h:49
msgid "PC/IX"
msgstr "PC/IX"

#: include/pt-mbr-partnames.h:50
msgid "Old Minix"
msgstr "旧 Minix"

#: include/pt-mbr-partnames.h:51
msgid "Minix / old Linux"
msgstr "Minix / 旧 Linux"

#: include/pt-mbr-partnames.h:52
msgid "Linux swap / Solaris"
msgstr "Linux swap / Solaris"

#: include/pt-mbr-partnames.h:53
msgid "Linux"
msgstr "Linux"

#: include/pt-mbr-partnames.h:54
msgid "OS/2 hidden or Intel hibernation"
msgstr "OS/2 隐藏 或 Intel 休眠"

#: include/pt-mbr-partnames.h:57
msgid "Linux extended"
msgstr "Linux 扩展"

#: include/pt-mbr-partnames.h:58 include/pt-mbr-partnames.h:59
msgid "NTFS volume set"
msgstr "NTFS 卷集"

#: include/pt-mbr-partnames.h:60
msgid "Linux plaintext"
msgstr "Linux 纯文本"

#: include/pt-mbr-partnames.h:61 libfdisk/src/gpt.c:204 libfdisk/src/sgi.c:62
#: libfdisk/src/sun.c:53
msgid "Linux LVM"
msgstr "Linux LVM"

#: include/pt-mbr-partnames.h:62
msgid "Amoeba"
msgstr "Amoeba"

#: include/pt-mbr-partnames.h:63
msgid "Amoeba BBT"
msgstr "Amoeba BBT"

#: include/pt-mbr-partnames.h:64
msgid "BSD/OS"
msgstr "BSD/OS"

#: include/pt-mbr-partnames.h:65
msgid "IBM Thinkpad hibernation"
msgstr "IBM Thinkpad 休眠"

#: include/pt-mbr-partnames.h:66
msgid "FreeBSD"
msgstr "FreeBSD"

#: include/pt-mbr-partnames.h:67
msgid "OpenBSD"
msgstr "OpenBSD"

#: include/pt-mbr-partnames.h:68
msgid "NeXTSTEP"
msgstr "NeXTSTEP"

#: include/pt-mbr-partnames.h:69
msgid "Darwin UFS"
msgstr "Darwin UFS"

#: include/pt-mbr-partnames.h:70
msgid "NetBSD"
msgstr "NetBSD"

#: include/pt-mbr-partnames.h:71
msgid "Darwin boot"
msgstr "Darwin 启动"

#: include/pt-mbr-partnames.h:72
msgid "HFS / HFS+"
msgstr "HFS / HFS+"

#: include/pt-mbr-partnames.h:73
msgid "BSDI fs"
msgstr "BSDI fs"

#: include/pt-mbr-partnames.h:74
msgid "BSDI swap"
msgstr "BSDI swap"

#: include/pt-mbr-partnames.h:75
msgid "Boot Wizard hidden"
msgstr "Boot Wizard 隐藏"

#: include/pt-mbr-partnames.h:76
msgid "Acronis FAT32 LBA"
msgstr "Acronis FAT32 LBA"

#: include/pt-mbr-partnames.h:77 libfdisk/src/gpt.c:229
msgid "Solaris boot"
msgstr "Solaris 启动"

#: include/pt-mbr-partnames.h:78
msgid "Solaris"
msgstr "Solaris"

#: include/pt-mbr-partnames.h:79
msgid "DRDOS/sec (FAT-12)"
msgstr "DRDOS/sec (FAT-12)"

#: include/pt-mbr-partnames.h:80
msgid "DRDOS/sec (FAT-16 < 32M)"
msgstr "DRDOS/sec (FAT-16 < 32M)"

#: include/pt-mbr-partnames.h:81
msgid "DRDOS/sec (FAT-16)"
msgstr "DRDOS/sec (FAT-16)"

#: include/pt-mbr-partnames.h:82
msgid "Syrinx"
msgstr "Syrinx"

#: include/pt-mbr-partnames.h:83
msgid "Non-FS data"
msgstr "非文件系统数据"

#: include/pt-mbr-partnames.h:84
msgid "CP/M / CTOS / ..."
msgstr "CP/M / CTOS / ..."

#: include/pt-mbr-partnames.h:86
msgid "Dell Utility"
msgstr "Dell 工具"

#: include/pt-mbr-partnames.h:87
msgid "BootIt"
msgstr "BootIt"

#: include/pt-mbr-partnames.h:88
msgid "DOS access"
msgstr "DOS 访问"

#: include/pt-mbr-partnames.h:90
msgid "DOS R/O"
msgstr "DOS R/O"

#: include/pt-mbr-partnames.h:93
msgid "Rufus alignment"
msgstr "Rufus 对齐"

#: include/pt-mbr-partnames.h:94
msgid "BeOS fs"
msgstr "BeOS fs"

#: include/pt-mbr-partnames.h:96
msgid "EFI (FAT-12/16/32)"
msgstr "EFI (FAT-12/16/32)"

#: include/pt-mbr-partnames.h:97
msgid "Linux/PA-RISC boot"
msgstr "Linux/PA-RISC 启动"

#: include/pt-mbr-partnames.h:100
msgid "DOS secondary"
msgstr "DOS 次要"

#: include/pt-mbr-partnames.h:101 libfdisk/src/gpt.c:274
msgid "VMware VMFS"
msgstr "VMware VMFS"

#: include/pt-mbr-partnames.h:102
msgid "VMware VMKCORE"
msgstr "VMware VMKCORE"

#: include/pt-mbr-partnames.h:103 libfdisk/src/sun.c:54
msgid "Linux raid autodetect"
msgstr "Linux raid 自动检测"

#: include/pt-mbr-partnames.h:106
msgid "LANstep"
msgstr "LANstep"

#: include/pt-mbr-partnames.h:107
msgid "BBT"
msgstr "BBT"

#: lib/blkdev.c:273
#, c-format
msgid "warning: %s is misaligned"
msgstr "警告：%s 未正确对齐"

#: libfdisk/src/ask.c:480 libfdisk/src/ask.c:492
#, c-format
msgid "Selected partition %ju"
msgstr "已选择分区 %ju"

#: libfdisk/src/ask.c:483
msgid "No partition is defined yet!"
msgstr "还没有定义分区！"

#: libfdisk/src/ask.c:495
msgid "No free partition available!"
msgstr "无空闲分区可用！"

#: libfdisk/src/ask.c:505
msgid "Partition number"
msgstr "分区号"

#: libfdisk/src/ask.c:1002
#, c-format
msgid "Created a new partition %d of type '%s' and of size %s."
msgstr "创建了一个新分区 %d，类型为“%s”，大小为 %s。"

#: libfdisk/src/bsd.c:165
#, c-format
msgid "Partition %zd: has invalid starting sector 0."
msgstr "分区 %zd：无效的起始扇区 0。"

#: libfdisk/src/bsd.c:180
#, c-format
msgid "There is no *BSD partition on %s."
msgstr "%s 上没有 *BSD 分区。"

#: libfdisk/src/bsd.c:258 libfdisk/src/dos.c:982
msgid "First cylinder"
msgstr "第一个柱面"

#: libfdisk/src/bsd.c:291 libfdisk/src/dos.c:1213
msgid "Last cylinder, +cylinders or +size{K,M,G,T,P}"
msgstr "最后一个柱面, +cylinders 或 +size{K,M,G,T,P}"

#: libfdisk/src/bsd.c:296 libfdisk/src/dos.c:1218 libfdisk/src/gpt.c:2447
msgid "Last sector, +sectors or +size{K,M,G,T,P}"
msgstr "上个扇区，+sectors 或 +size{K,M,G,T,P}"

#: libfdisk/src/bsd.c:380
#, c-format
msgid "The device %s does not contain BSD disklabel."
msgstr "设备 %s 不包含BSD 磁盘标签。"

#: libfdisk/src/bsd.c:382
msgid "Do you want to create a BSD disklabel?"
msgstr "您想创建一个 BSD 磁盘标签吗？"

#: libfdisk/src/bsd.c:448
msgid "Disk"
msgstr "磁盘"

#: libfdisk/src/bsd.c:455
msgid "Packname"
msgstr "包名"

#: libfdisk/src/bsd.c:462 libfdisk/src/sun.c:1127
msgid "Flags"
msgstr "标志"

#: libfdisk/src/bsd.c:465
msgid " removable"
msgstr " 可移动"

#: libfdisk/src/bsd.c:466
msgid " ecc"
msgstr " ecc"

#: libfdisk/src/bsd.c:467
msgid " badsect"
msgstr " 坏扇区"

#: libfdisk/src/bsd.c:475
msgid "Bytes/Sector"
msgstr "字节/扇区"

#: libfdisk/src/bsd.c:480
msgid "Tracks/Cylinder"
msgstr "磁道/柱面"

#: libfdisk/src/bsd.c:485
msgid "Sectors/Cylinder"
msgstr "扇区/柱面"

#: libfdisk/src/bsd.c:490 libfdisk/src/bsd.c:1020 libfdisk/src/dos.c:2428
#: libfdisk/src/sgi.c:1156 libfdisk/src/sun.c:197 libfdisk/src/sun.c:1123
msgid "Cylinders"
msgstr "柱面"

#: libfdisk/src/bsd.c:495 libfdisk/src/sun.c:773
msgid "Rpm"
msgstr "转每分"

#: libfdisk/src/bsd.c:500 libfdisk/src/sgi.c:291 libfdisk/src/sun.c:793
msgid "Interleave"
msgstr "交错"

#: libfdisk/src/bsd.c:505
msgid "Trackskew"
msgstr "磁道螺距"

#: libfdisk/src/bsd.c:510
msgid "Cylinderskew"
msgstr "柱头螺距"

#: libfdisk/src/bsd.c:515
msgid "Headswitch"
msgstr "磁头切换"

#: libfdisk/src/bsd.c:520
msgid "Track-to-track seek"
msgstr "跨磁道定位"

#: libfdisk/src/bsd.c:610
msgid "bytes/sector"
msgstr "字节/扇区"

#: libfdisk/src/bsd.c:613
msgid "sectors/track"
msgstr "扇区/磁道"

#: libfdisk/src/bsd.c:614
msgid "tracks/cylinder"
msgstr "磁道/柱面"

#: libfdisk/src/bsd.c:615
msgid "cylinders"
msgstr "柱面"

#: libfdisk/src/bsd.c:619
msgid "sectors/cylinder"
msgstr "扇区/柱面"

#: libfdisk/src/bsd.c:622
msgid "rpm"
msgstr "rpm"

#: libfdisk/src/bsd.c:623
msgid "interleave"
msgstr "交错"

#: libfdisk/src/bsd.c:624
msgid "trackskew"
msgstr "磁道螺距"

#: libfdisk/src/bsd.c:625
msgid "cylinderskew"
msgstr "柱头螺距"

#: libfdisk/src/bsd.c:627
msgid "headswitch"
msgstr "磁头切换"

#: libfdisk/src/bsd.c:628
msgid "track-to-track seek"
msgstr "跨磁道定位"

#: libfdisk/src/bsd.c:650
#, c-format
msgid "The bootstrap file %s successfully loaded."
msgstr "成功加载了引导程序文件 %s。"

#: libfdisk/src/bsd.c:672
#, c-format
msgid "Bootstrap: %1$sboot -> boot%1$s (default %1$s)"
msgstr "引导：%1$sboot -> boot%1$s (默认 %1$s)"

#: libfdisk/src/bsd.c:703
msgid "Bootstrap overlaps with disklabel!"
msgstr "引导程序与磁盘标签重叠！"

#: libfdisk/src/bsd.c:727
#, c-format
msgid "Bootstrap installed on %s."
msgstr "已在 %s 上安装引导程序。"

#: libfdisk/src/bsd.c:902
#, c-format
msgid "Disklabel written to %s.  (Don't forget to write the %s disklabel too.)"
msgstr "磁盘标签已写入 %s。(不要忘了也写入 %s 磁盘标签。)"

#: libfdisk/src/bsd.c:905
#, c-format
msgid "Disklabel written to %s."
msgstr "磁盘标签已写入 %s。"

#: libfdisk/src/bsd.c:911 libfdisk/src/context.c:688
msgid "Syncing disks."
msgstr "正在同步磁盘。"

#: libfdisk/src/bsd.c:952
msgid "BSD label is not nested within a DOS partition."
msgstr "BSD 标签未嵌套在 DOS 分区中。"

#: libfdisk/src/bsd.c:980
#, c-format
msgid "BSD partition '%c' linked to DOS partition %zu."
msgstr "BSD 分区“%c”已链接到 DOS 分区 %zu。"

#: libfdisk/src/bsd.c:1016
msgid "Slice"
msgstr "片"

#: libfdisk/src/bsd.c:1023
msgid "Fsize"
msgstr "Fsize"

#: libfdisk/src/bsd.c:1024
msgid "Bsize"
msgstr "Bsize"

#: libfdisk/src/bsd.c:1025
msgid "Cpg"
msgstr "Cpg"

#: libfdisk/src/context.c:682
#, c-format
msgid "%s: close device failed"
msgstr "%s：关闭设备失败"

#: libfdisk/src/context.c:756
msgid "Calling ioctl() to re-read partition table."
msgstr "将调用 ioctl() 来重新读分区表。"

#: libfdisk/src/context.c:765
msgid "Re-reading the partition table failed."
msgstr "重新读取分区表失败。"

#: libfdisk/src/context.c:767
msgid "The kernel still uses the old table. The new table will be used at the next reboot or after you run partprobe(8) or kpartx(8)."
msgstr "内核仍在使用旧分区表。新分区表将在下次重启或运行 partprobe(8) 或 kpartx(8) 后生效。"

#: libfdisk/src/context.c:852
#, fuzzy, c-format
msgid "Failed to remove partition %zu from system"
msgstr "移除分区失败"

#: libfdisk/src/context.c:860
#, fuzzy, c-format
msgid "Failed to update system information about partition %zu"
msgstr "打印某个分区的相关信息"

#: libfdisk/src/context.c:868
#, fuzzy, c-format
msgid "Failed to add partition %zu to system"
msgstr "添加分区失败"

#: libfdisk/src/context.c:874
#, fuzzy
msgid "The kernel still uses the old partitions. The new table will be used at the next reboot. "
msgstr "内核仍在使用旧分区表。新分区表将在下次重启或运行 partprobe(8) 或 kpartx(8) 后生效。"

#: libfdisk/src/context.c:1084
msgid "cylinder"
msgid_plural "cylinders"
msgstr[0] "柱面"

#: libfdisk/src/context.c:1085
msgid "sector"
msgid_plural "sectors"
msgstr[0] "扇区"

#: libfdisk/src/context.c:1388
msgid "Incomplete geometry setting."
msgstr "不完整的几何属性设置。"

#: libfdisk/src/dos.c:213
msgid "All primary partitions have been defined already."
msgstr "已经定义了所有主分区。"

#: libfdisk/src/dos.c:216
#, fuzzy
msgid "Primary partition not available."
msgstr "无空闲分区可用！"

#: libfdisk/src/dos.c:270
#, c-format
msgid "Failed to read extended partition table (offset=%ju)"
msgstr "读取扩展分区表失败(偏移=%ju)"

#: libfdisk/src/dos.c:340
msgid "You can set geometry from the extra functions menu."
msgstr "您可以从 更多功能 菜单获取几何属性。"

#: libfdisk/src/dos.c:343
msgid "DOS-compatible mode is deprecated."
msgstr "DOS 兼容模式已废弃。"

#: libfdisk/src/dos.c:347
msgid "The device presents a logical sector size that is smaller than the physical sector size. Aligning to a physical sector (or optimal I/O) size boundary is recommended, or performance may be impacted."
msgstr "设备上存在一个小于物理扇区尺寸的逻辑扇区尺寸。建议您对齐到物理扇区(或最佳 I/O)尺寸边界，否则性能可能受影响。"

#: libfdisk/src/dos.c:353
msgid "Cylinders as display units are deprecated."
msgstr "以柱面为显示单位的方式已废弃。"

#: libfdisk/src/dos.c:360
#, fuzzy, c-format
msgid "The size of this disk is %s (%ju bytes). DOS partition table format cannot be used on drives for volumes larger than %lu bytes for %lu-byte sectors. Use GUID partition table format (GPT)."
msgstr "该磁盘的大小为 %s (%ju 个字节)。DOS 分区表不能用于卷容量大于 %lu 字节，%lu 字节扇区的驱动器。请使用 GUID 分区表格式(GPT)。"

#: libfdisk/src/dos.c:534
msgid "Bad offset in primary extended partition."
msgstr "主扩展分区中的偏移错误。"

#: libfdisk/src/dos.c:548
#, c-format
msgid "Omitting partitions after #%zu. They will be deleted if you save this partition table."
msgstr "警告：将忽略 #%zu 后的扇区。如果您保存此分区表，它们会被删除。"

#: libfdisk/src/dos.c:581
#, c-format
msgid "Extra link pointer in partition table %zu."
msgstr "在分区表 %zu 中有额外链接指针。"

#: libfdisk/src/dos.c:589
#, c-format
msgid "Ignoring extra data in partition table %zu."
msgstr "将忽略分区表 %zu 中的额外数据。"

#: libfdisk/src/dos.c:645
#, c-format
msgid "omitting empty partition (%zu)"
msgstr "将忽略空分区(%zu)"

#: libfdisk/src/dos.c:705
#, c-format
msgid "Created a new DOS disklabel with disk identifier 0x%08x."
msgstr "创建了一个磁盘标识符为 0x%08x 的新 DOS 磁盘标签。"

#: libfdisk/src/dos.c:726
msgid "Enter the new disk identifier"
msgstr "输入新磁盘标识符"

#: libfdisk/src/dos.c:733
msgid "Incorrect value."
msgstr "无效的值。"

#: libfdisk/src/dos.c:742
#, c-format
msgid "Disk identifier changed from 0x%08x to 0x%08x."
msgstr "磁盘标识从 0x%08x 改为 0x%08x。"

#: libfdisk/src/dos.c:838
#, c-format
msgid "Ignoring extra extended partition %zu"
msgstr "将忽略额外的扩展分区 %zu"

#: libfdisk/src/dos.c:852
#, c-format
msgid "Invalid flag 0x%02x%02x of EBR (for partition %zu) will be corrected by w(rite)."
msgstr "分区表 %3$zu 的无效标志 0x%1$02x%2$02x 将通过写入来更正"

#: libfdisk/src/dos.c:969
#, c-format
msgid "Start sector %ju out of range."
msgstr "起始扇区 %ju 超出范围。"

#: libfdisk/src/dos.c:1076 libfdisk/src/gpt.c:2321 libfdisk/src/sgi.c:838
#: libfdisk/src/sun.c:520
#, c-format
msgid "Partition %zu is already defined.  Delete it before re-adding it."
msgstr "分区 %zu 已经定义过。请删除后再重新添加它。"

#: libfdisk/src/dos.c:1146
#, c-format
msgid "Sector %llu is already allocated."
msgstr "扇区 %llu 已经分配."

#: libfdisk/src/dos.c:1185 libfdisk/src/gpt.c:2330
msgid "No free sectors available."
msgstr "无空闲扇区可用。"

#: libfdisk/src/dos.c:1341
#, c-format
msgid "Adding logical partition %zu"
msgstr "添加逻辑分区 %zu"

#: libfdisk/src/dos.c:1372
#, c-format
msgid "Partition %zu: contains sector 0"
msgstr "分区 %zu：包含扇区 0"

#: libfdisk/src/dos.c:1374
#, c-format
msgid "Partition %zu: head %d greater than maximum %d"
msgstr "分区 %zu：磁头 %d 大于最大值 %d"

#: libfdisk/src/dos.c:1377
#, c-format
msgid "Partition %zu: sector %d greater than maximum %llu"
msgstr "分区 %zu：扇区 %d 大于最大值 %llu"

#: libfdisk/src/dos.c:1380
#, c-format
msgid "Partition %zu: cylinder %d greater than maximum %llu"
msgstr "分区 %zu：柱面 %d 大于最大值 %llu"

#: libfdisk/src/dos.c:1386
#, c-format
msgid "Partition %zu: previous sectors %u disagrees with total %u"
msgstr "分区 %zu：之前的扇区数 %u 与总数 %u 不符"

#: libfdisk/src/dos.c:1439
#, c-format
msgid "Partition %zu: different physical/logical beginnings (non-Linux?): phys=(%d, %d, %d), logical=(%d, %d, %d)"
msgstr "分区 %zu 的物理/逻辑起点不同(非 Linux 分区？)：物理=(%d, %d, %d), 逻辑=(%d, %d, %d)"

#: libfdisk/src/dos.c:1450
#, c-format
msgid "Partition %zu: different physical/logical endings: phys=(%d, %d, %d), logical=(%d, %d, %d)"
msgstr "分区 %zu 的物理/逻辑终点不同：物理=(%d, %d, %d), 逻辑=(%d, %d, %d)"

#: libfdisk/src/dos.c:1459
#, c-format
msgid "Partition %zu: does not end on cylinder boundary."
msgstr "分区 %zu 未结束在柱面边界上。"

#: libfdisk/src/dos.c:1486
#, c-format
msgid "Partition %zu: bad start-of-data."
msgstr "分区 %zu：数据起点错误。"

#: libfdisk/src/dos.c:1499
#, c-format
msgid "Partition %zu: overlaps partition %zu."
msgstr "分区 %zu：与 分区 %zu 重叠。"

#: libfdisk/src/dos.c:1527
#, c-format
msgid "Partition %zu: empty."
msgstr "分区 %zu：空分区。"

#: libfdisk/src/dos.c:1532
#, c-format
msgid "Logical partition %zu: not entirely in partition %zu."
msgstr "逻辑分区 %zu：没有完全在分区 %zu 中。"

#: libfdisk/src/dos.c:1540
#, c-format
msgid "Total allocated sectors %llu greater than the maximum %llu."
msgstr "分配的总扇区数 %llu 大于最大值 %llu。"

#: libfdisk/src/dos.c:1543
#, c-format
msgid "Remaining %lld unallocated %ld-byte sectors."
msgstr "剩余 %lld 未分配的 %ld字节 扇区。"

#: libfdisk/src/dos.c:1601 libfdisk/src/dos.c:1616 libfdisk/src/dos.c:2063
msgid "Extended partition already exists."
msgstr "扩展分区已存在。"

#: libfdisk/src/dos.c:1631
msgid "Extended partition does not exists. Failed to add logical partition."
msgstr ""

#: libfdisk/src/dos.c:1667
msgid "The maximum number of partitions has been created."
msgstr "已创建分区达到最大数量。"

#: libfdisk/src/dos.c:1681
msgid "All primary partitions are in use."
msgstr "所有主分区都在使用中。"

#: libfdisk/src/dos.c:1683 libfdisk/src/dos.c:1694
msgid "All space for primary partitions is in use."
msgstr "所有主分区的空间都在使用中。"

#. TRANSLATORS: Try to keep this within 80 characters.
#: libfdisk/src/dos.c:1697
msgid "To create more partitions, first replace a primary with an extended partition."
msgstr "要创建更多分区，请先将一个主分区替换为扩展分区。"

#: libfdisk/src/dos.c:1702
msgid "All logical partitions are in use. Adding a primary partition."
msgstr "所有逻辑分区都在使用中。将添加一个主分区。"

#: libfdisk/src/dos.c:1724
msgid "Partition type"
msgstr "分区类型"

#: libfdisk/src/dos.c:1728
#, c-format
msgid "%zu primary, %d extended, %zu free"
msgstr "%zu个主分区，%d个扩展分区，%zu空闲"

#: libfdisk/src/dos.c:1733
msgid "primary"
msgstr "主分区"

#: libfdisk/src/dos.c:1735
msgid "extended"
msgstr "扩展分区"

#: libfdisk/src/dos.c:1735
msgid "container for logical partitions"
msgstr "逻辑分区容器"

#: libfdisk/src/dos.c:1737
msgid "logical"
msgstr "逻辑分区"

#: libfdisk/src/dos.c:1737
msgid "numbered from 5"
msgstr "从 5 开始编号"

#: libfdisk/src/dos.c:1776
#, c-format
msgid "Invalid partition type `%c'."
msgstr "无效的分区类型“%c”。"

#: libfdisk/src/dos.c:1794
#, c-format
msgid "Cannot write sector %jd: seek failed"
msgstr "写扇区 %jd 失败：定位失败"

#: libfdisk/src/dos.c:1954 libfdisk/src/gpt.c:1221
msgid "Disk identifier"
msgstr "磁盘标识符"

#: libfdisk/src/dos.c:2068
msgid "Type 0 means free space to many systems. Having partitions of type 0 is probably unwise."
msgstr "很多系统将类型 0 视为空闲空间。不建议设置类型为 0 的分区。"

#: libfdisk/src/dos.c:2073
msgid "Cannot change type of the extended partition which is already used by logical partitions. Delete logical partitions first."
msgstr "无法更改已被逻辑分区使用的扩展分区的类型。请先删除逻辑分区。"

#: libfdisk/src/dos.c:2259 libfdisk/src/gpt.c:3037
msgid "Nothing to do. Ordering is correct already."
msgstr "无须操作。顺序已经是正确的了。"

#: libfdisk/src/dos.c:2314
#, c-format
msgid "Partition %zu: no data area."
msgstr "分区 %zu：无数据区。"

#: libfdisk/src/dos.c:2347
msgid "New beginning of data"
msgstr "新数据起点"

#: libfdisk/src/dos.c:2403
#, c-format
msgid "Partition %zu: is an extended partition."
msgstr "分区 %zu：是一个扩展分区。"

#: libfdisk/src/dos.c:2409
#, c-format
msgid "The bootable flag on partition %zu is enabled now."
msgstr "分区 %zu 的 可启动 标志已启用。"

#: libfdisk/src/dos.c:2410
#, c-format
msgid "The bootable flag on partition %zu is disabled now."
msgstr "分区 %zu 的 可启动 标志已禁用。"

#: libfdisk/src/dos.c:2423 libfdisk/src/gpt.c:3127 libfdisk/src/sgi.c:1152
#: libfdisk/src/sun.c:1119
msgid "Device"
msgstr "设备"

#: libfdisk/src/dos.c:2424 libfdisk/src/sun.c:40
msgid "Boot"
msgstr "启动"

#: libfdisk/src/dos.c:2430 libfdisk/src/sgi.c:1158 libfdisk/src/sun.c:1125
msgid "Id"
msgstr "Id"

#: libfdisk/src/dos.c:2434
msgid "Start-C/H/S"
msgstr "起始-C/H/S"

#: libfdisk/src/dos.c:2435
msgid "End-C/H/S"
msgstr "终-C/H/S"

#: libfdisk/src/dos.c:2436 libfdisk/src/gpt.c:3137 libfdisk/src/sgi.c:1160
msgid "Attrs"
msgstr "属性"

#: libfdisk/src/gpt.c:159
msgid "EFI System"
msgstr "EFI 系统"

#: libfdisk/src/gpt.c:161
msgid "MBR partition scheme"
msgstr "MBR 分区方案"

#: libfdisk/src/gpt.c:162
msgid "Intel Fast Flash"
msgstr "Intel Fast Flash"

#: libfdisk/src/gpt.c:165
msgid "BIOS boot"
msgstr "BIOS 启动"

#: libfdisk/src/gpt.c:168
msgid "Sony boot partition"
msgstr "Sony 启动分区"

#: libfdisk/src/gpt.c:169
msgid "Lenovo boot partition"
msgstr "Lenovo 启动分区"

#: libfdisk/src/gpt.c:172
msgid "PowerPC PReP boot"
msgstr "PowerPC PReP boot"

#: libfdisk/src/gpt.c:175
msgid "ONIE boot"
msgstr "ONIE boot"

#: libfdisk/src/gpt.c:176
msgid "ONIE config"
msgstr "ONIE 配置"

#: libfdisk/src/gpt.c:179
msgid "Microsoft reserved"
msgstr "Microsoft 保留"

#: libfdisk/src/gpt.c:180
msgid "Microsoft basic data"
msgstr "Microsoft 基本数据"

#: libfdisk/src/gpt.c:181
msgid "Microsoft LDM metadata"
msgstr "Microsoft LDM 元数据"

#: libfdisk/src/gpt.c:182
msgid "Microsoft LDM data"
msgstr "Microsoft LDM 数据"

#: libfdisk/src/gpt.c:183
msgid "Windows recovery environment"
msgstr "Windows 恢复环境"

#: libfdisk/src/gpt.c:184
msgid "IBM General Parallel Fs"
msgstr "IBM 通用并行文件系统"

#: libfdisk/src/gpt.c:185
msgid "Microsoft Storage Spaces"
msgstr "Microsoft 存储空间"

#: libfdisk/src/gpt.c:188
msgid "HP-UX data"
msgstr "HP-UX 数据"

#: libfdisk/src/gpt.c:189
msgid "HP-UX service"
msgstr "HP-UX 服务"

#: libfdisk/src/gpt.c:192 libfdisk/src/sgi.c:60 libfdisk/src/sun.c:51
msgid "Linux swap"
msgstr "Linux swap"

#: libfdisk/src/gpt.c:193
msgid "Linux filesystem"
msgstr "Linux 文件系统"

#: libfdisk/src/gpt.c:194
msgid "Linux server data"
msgstr "Linux 保留数据"

#: libfdisk/src/gpt.c:195
msgid "Linux root (x86)"
msgstr "Linux root (x86)"

#: libfdisk/src/gpt.c:196
msgid "Linux root (ARM)"
msgstr "Linux root (ARM)"

#: libfdisk/src/gpt.c:197
msgid "Linux root (x86-64)"
msgstr "Linux root (x86-64)"

#: libfdisk/src/gpt.c:198
msgid "Linux root (ARM-64)"
msgstr "Linux root (ARM-64)"

#: libfdisk/src/gpt.c:199
msgid "Linux root\t(IA-64)"
msgstr "Linux root\t(IA-64)"

#: libfdisk/src/gpt.c:200
msgid "Linux reserved"
msgstr "Linux 保留"

#: libfdisk/src/gpt.c:201
msgid "Linux home"
msgstr "Linux home"

#: libfdisk/src/gpt.c:202 libfdisk/src/sgi.c:63
msgid "Linux RAID"
msgstr "Linux RAID"

#: libfdisk/src/gpt.c:203
msgid "Linux extended boot"
msgstr "Linux 扩展启动"

#: libfdisk/src/gpt.c:211
msgid "FreeBSD data"
msgstr "FreeBSD 数据"

#: libfdisk/src/gpt.c:212
msgid "FreeBSD boot"
msgstr "FreeBSD 启动"

#: libfdisk/src/gpt.c:213
msgid "FreeBSD swap"
msgstr "FreeBSD 交换"

#: libfdisk/src/gpt.c:214
msgid "FreeBSD UFS"
msgstr "FreeBSD UFS"

#: libfdisk/src/gpt.c:215
msgid "FreeBSD ZFS"
msgstr "FreeBSD ZFS"

#: libfdisk/src/gpt.c:216
msgid "FreeBSD Vinum"
msgstr "FreeBSD Vinum"

#: libfdisk/src/gpt.c:219
msgid "Apple HFS/HFS+"
msgstr "Apple HFS/HFS+"

#: libfdisk/src/gpt.c:220
msgid "Apple UFS"
msgstr "Apple UFS"

#: libfdisk/src/gpt.c:221
msgid "Apple RAID"
msgstr "Apple RAID"

#: libfdisk/src/gpt.c:222
msgid "Apple RAID offline"
msgstr "Apple RAID 离线"

#: libfdisk/src/gpt.c:223
msgid "Apple boot"
msgstr "Apple 启动"

#: libfdisk/src/gpt.c:224
msgid "Apple label"
msgstr "Apple 标签"

#: libfdisk/src/gpt.c:225
msgid "Apple TV recovery"
msgstr "Apple TV 恢复"

#: libfdisk/src/gpt.c:226
msgid "Apple Core storage"
msgstr "Apple Core 存储"

#: libfdisk/src/gpt.c:230
msgid "Solaris root"
msgstr "Solaris root"

#: libfdisk/src/gpt.c:232
msgid "Solaris /usr & Apple ZFS"
msgstr "Solaris /usr & Apple ZFS"

#: libfdisk/src/gpt.c:233
msgid "Solaris swap"
msgstr "Solaris 交换"

#: libfdisk/src/gpt.c:234
msgid "Solaris backup"
msgstr "Solaris 备份"

#: libfdisk/src/gpt.c:235
msgid "Solaris /var"
msgstr "Solaris /var"

#: libfdisk/src/gpt.c:236
msgid "Solaris /home"
msgstr "Solaris /home"

#: libfdisk/src/gpt.c:237
msgid "Solaris alternate sector"
msgstr "Solaris 备选扇区"

#: libfdisk/src/gpt.c:238
msgid "Solaris reserved 1"
msgstr "Solaris 保留 1"

#: libfdisk/src/gpt.c:239
msgid "Solaris reserved 2"
msgstr "Solaris 保留 2"

#: libfdisk/src/gpt.c:240
msgid "Solaris reserved 3"
msgstr "Solaris 保留 3"

#: libfdisk/src/gpt.c:241
msgid "Solaris reserved 4"
msgstr "Solaris 保留 4"

#: libfdisk/src/gpt.c:242
msgid "Solaris reserved 5"
msgstr "Solaris 保留 5"

#: libfdisk/src/gpt.c:245
msgid "NetBSD swap"
msgstr "NetBSD 交换"

#: libfdisk/src/gpt.c:246
msgid "NetBSD FFS"
msgstr "NetBSD FFS"

#: libfdisk/src/gpt.c:247
msgid "NetBSD LFS"
msgstr "NetBSD LFS"

#: libfdisk/src/gpt.c:248
msgid "NetBSD concatenated"
msgstr "NetBSD concatenated"

#: libfdisk/src/gpt.c:249
msgid "NetBSD encrypted"
msgstr "NetBSD 加密"

#: libfdisk/src/gpt.c:250
msgid "NetBSD RAID"
msgstr "NetBSD RAID"

#: libfdisk/src/gpt.c:253
msgid "ChromeOS kernel"
msgstr "ChromeOS 内核"

#: libfdisk/src/gpt.c:254
msgid "ChromeOS root fs"
msgstr "ChromeOS 根文件系统"

#: libfdisk/src/gpt.c:255
msgid "ChromeOS reserved"
msgstr "ChromeOS 保留"

#: libfdisk/src/gpt.c:258
msgid "MidnightBSD data"
msgstr "MidnightBSD 数据"

#: libfdisk/src/gpt.c:259
msgid "MidnightBSD boot"
msgstr "MidnightBSD 启动"

#: libfdisk/src/gpt.c:260
msgid "MidnightBSD swap"
msgstr "MidnightBSD 交换"

#: libfdisk/src/gpt.c:261
msgid "MidnightBSD UFS"
msgstr "MidnightBSD UFS"

#: libfdisk/src/gpt.c:262
msgid "MidnightBSD ZFS"
msgstr "MidnightBSD ZFS"

#: libfdisk/src/gpt.c:263
msgid "MidnightBSD Vinum"
msgstr "MidnightBSD Vinum"

#: libfdisk/src/gpt.c:266
msgid "Ceph Journal"
msgstr "Ceph 日志"

#: libfdisk/src/gpt.c:267
msgid "Ceph Encrypted Journal"
msgstr "Ceph 加密日志"

#: libfdisk/src/gpt.c:268
msgid "Ceph OSD"
msgstr "Ceph OSD"

#: libfdisk/src/gpt.c:269
msgid "Ceph crypt OSD"
msgstr "Ceph 加密 OSD"

#: libfdisk/src/gpt.c:270
msgid "Ceph disk in creation"
msgstr "创建中的 Ceph 磁盘"

#: libfdisk/src/gpt.c:271
msgid "Ceph crypt disk in creation"
msgstr "创建中的加密 Ceph 磁盘"

#: libfdisk/src/gpt.c:275
#, fuzzy
msgid "VMware Diagnostic"
msgstr "Compaq 诊断"

#: libfdisk/src/gpt.c:276
#, fuzzy
msgid "VMware Virtual SAN"
msgstr "VMware VMFS"

#: libfdisk/src/gpt.c:277
#, fuzzy
msgid "VMware Virsto"
msgstr "VMware VMFS"

#: libfdisk/src/gpt.c:278
#, fuzzy
msgid "VMware Reserved"
msgstr "ChromeOS 保留"

#: libfdisk/src/gpt.c:281
msgid "OpenBSD data"
msgstr "OpenBSD 数据"

#: libfdisk/src/gpt.c:284
msgid "QNX6 file system"
msgstr "QNX6 文件系统"

#: libfdisk/src/gpt.c:287
msgid "Plan 9 partition"
msgstr "Plan 9 分区"

#: libfdisk/src/gpt.c:661
msgid "failed to allocate GPT header"
msgstr "分配 GPT 头失败"

#: libfdisk/src/gpt.c:744
msgid "First LBA specified by script is out of range."
msgstr "脚本指定的第一个 LBA 超出范围。"

#: libfdisk/src/gpt.c:756
msgid "Last LBA specified by script is out of range."
msgstr "脚本指定的最后一个 LBA 超出范围。"

#: libfdisk/src/gpt.c:895
#, fuzzy, c-format
msgid "GPT PMBR size mismatch (%<PRIu64> != %<PRIu64>) will be corrected by write."
msgstr "GPT PMBR 大小不符(%<PRIu64> != %<PRIu64>)，将用 w(写) 予以更正。"

#: libfdisk/src/gpt.c:917
msgid "gpt: stat() failed"
msgstr "gpt：stat() 失败"

#: libfdisk/src/gpt.c:927
#, c-format
msgid "gpt: cannot handle files with mode %o"
msgstr "gpt：无法操作模式为 %o 的文件"

#: libfdisk/src/gpt.c:1191
msgid "GPT Header"
msgstr "GPT 头"

#: libfdisk/src/gpt.c:1196
msgid "GPT Entries"
msgstr "GPT 记录项"

#: libfdisk/src/gpt.c:1228
msgid "First LBA"
msgstr "第一个 LBA"

#: libfdisk/src/gpt.c:1233
msgid "Last LBA"
msgstr "最后一个 LBA"

#. TRANSLATORS: The LBA (Logical Block Address) of the backup GPT header.
#: libfdisk/src/gpt.c:1239
msgid "Alternative LBA"
msgstr "替代 LBA"

#. TRANSLATORS: The start of the array of partition entries.
#: libfdisk/src/gpt.c:1245
msgid "Partition entries LBA"
msgstr "分区记录项 LBA"

#: libfdisk/src/gpt.c:1250
msgid "Allocated partition entries"
msgstr "已分配的分区项"

#: libfdisk/src/gpt.c:1595
msgid "The backup GPT table is corrupt, but the primary appears OK, so that will be used."
msgstr "备份 GPT 表损坏，但主表似乎正常，将使用它。"

#: libfdisk/src/gpt.c:1605
msgid "The primary GPT table is corrupt, but the backup appears OK, so that will be used."
msgstr "主 GPT 表损坏，但备份似乎正常，将使用它。"

#: libfdisk/src/gpt.c:1618
msgid "The backup GPT table is not on the end of the device. This problem will be corrected by write."
msgstr ""

#: libfdisk/src/gpt.c:1800
#, c-format
msgid "unsupported GPT attribute bit '%s'"
msgstr "不支持的 GPT 属性位“%s”"

#: libfdisk/src/gpt.c:1805
#, fuzzy, c-format
msgid "failed to parse GPT attribute string '%s'"
msgstr "解析列表“%s”失败"

#: libfdisk/src/gpt.c:1905
#, c-format
msgid "Partition UUID changed from %s to %s."
msgstr "分区 UUID 已从 %s 更改为 %s。"

#: libfdisk/src/gpt.c:1914
#, fuzzy
msgid "Failed to translate partition name, name not changed."
msgstr "分配分区名失败"

#: libfdisk/src/gpt.c:1916
#, c-format
msgid "Partition name changed from '%s' to '%.*s'."
msgstr "分区名已由“%s”改为“%.*s”。"

#: libfdisk/src/gpt.c:1945
msgid "The start of the partition understeps FirstUsableLBA."
msgstr "分区起点未到首个可用 LBA。"

#: libfdisk/src/gpt.c:1952
msgid "The end of the partition oversteps LastUsableLBA."
msgstr "分区终点超过了最后可用 LBA。"

#: libfdisk/src/gpt.c:2114
msgid "The device contains hybrid MBR -- writing GPT only. You have to sync the MBR manually."
msgstr "该设备包含混合 MBR -- 将只写入 GPT。您需要手动同步 MBR。"

#: libfdisk/src/gpt.c:2151
msgid "Disk does not contain a valid backup header."
msgstr "磁盘不含有效的备用磁头。"

#: libfdisk/src/gpt.c:2156
msgid "Invalid primary header CRC checksum."
msgstr "无效的主磁头 CRC 校验和。"

#: libfdisk/src/gpt.c:2160
msgid "Invalid backup header CRC checksum."
msgstr "无效的备份磁头 CRC 校验和。"

#: libfdisk/src/gpt.c:2165
msgid "Invalid partition entry checksum."
msgstr "无效的分区记录校验和。"

#: libfdisk/src/gpt.c:2170
msgid "Invalid primary header LBA sanity checks."
msgstr "无效的主磁头 LBA 完整性检查。"

#: libfdisk/src/gpt.c:2174
msgid "Invalid backup header LBA sanity checks."
msgstr "无效的备用磁头 LBA 完整性检查。"

#: libfdisk/src/gpt.c:2179
msgid "MyLBA mismatch with real position at primary header."
msgstr "MyLBA 不匹配，真正位置在主磁头。"

#: libfdisk/src/gpt.c:2183
msgid "MyLBA mismatch with real position at backup header."
msgstr "MyLBA 不匹配，真正位置在备份磁头。"

#: libfdisk/src/gpt.c:2188
msgid "Disk is too small to hold all data."
msgstr "磁盘太小，放不下所有数据。"

#: libfdisk/src/gpt.c:2198
msgid "Primary and backup header mismatch."
msgstr "主磁头和备份磁头不匹配。"

#: libfdisk/src/gpt.c:2204
#, c-format
msgid "Partition %u overlaps with partition %u."
msgstr "分区 %u 与 %u 重叠。"

#: libfdisk/src/gpt.c:2211
#, c-format
msgid "Partition %u is too big for the disk."
msgstr "分区 %u 对于该磁盘而言过大。"

#: libfdisk/src/gpt.c:2218
#, c-format
msgid "Partition %u ends before it starts."
msgstr "分区 %u 结束于起点之前。"

#: libfdisk/src/gpt.c:2227
msgid "No errors detected."
msgstr "未检测到错误。"

#: libfdisk/src/gpt.c:2228
#, c-format
msgid "Header version: %s"
msgstr "磁头版本：%s"

#: libfdisk/src/gpt.c:2229
#, fuzzy, c-format
msgid "Using %zu out of %zu partitions."
msgstr "使用着 %2$d 个分区中的 %1$u 个。"

#: libfdisk/src/gpt.c:2239
#, c-format
msgid "A total of %ju free sectors is available in %u segment."
msgid_plural "A total of %ju free sectors is available in %u segments (the largest is %s)."
msgstr[0] "%2$u 个片段中共有 %1$ju 个空闲扇区(最大的是 %3$s)。"

#: libfdisk/src/gpt.c:2247
#, c-format
msgid "%d error detected."
msgid_plural "%d errors detected."
msgstr[0] "检测到 %d 个错误。"

#: libfdisk/src/gpt.c:2326
msgid "All partitions are already in use."
msgstr "所有分区均已占用。"

#: libfdisk/src/gpt.c:2383 libfdisk/src/gpt.c:2410
#, c-format
msgid "Sector %ju already used."
msgstr "扇区 %ju 已使用。"

#: libfdisk/src/gpt.c:2475
#, c-format
msgid "Could not create partition %zu"
msgstr "无法创建分区 %zu"

#: libfdisk/src/gpt.c:2482
#, c-format
msgid "The last usable GPT sector is %ju, but %ju is requested."
msgstr "最后一个可用的 GPT 扇区是 %ju，但请求了 %ju。"

#: libfdisk/src/gpt.c:2489
#, c-format
msgid "The first usable GPT sector is %ju, but %ju is requested."
msgstr "第一个可用的 GPT 扇区是 %ju，但请求了 %ju。"

#: libfdisk/src/gpt.c:2628
#, c-format
msgid "Created a new GPT disklabel (GUID: %s)."
msgstr "已创建新的 GPT 磁盘标签(GUID: %s)。"

#: libfdisk/src/gpt.c:2646
msgid "Enter new disk UUID (in 8-4-4-4-12 format)"
msgstr "输入新磁盘 UUID(以 8-4-4-4-12 格式)"

#: libfdisk/src/gpt.c:2653
msgid "Failed to parse your UUID."
msgstr "解析您的 UUID 失败。"

#: libfdisk/src/gpt.c:2667
#, c-format
msgid "Disk identifier changed from %s to %s."
msgstr "将磁盘标识从 %s 更改为 %s 失败。"

#: libfdisk/src/gpt.c:2687
msgid "Not enough space for new partition table!"
msgstr "创建新分区表的空闲空间不够！"

#: libfdisk/src/gpt.c:2698
#, fuzzy, c-format
msgid "Partition #%zu out of range (minimal start is %<PRIu64> sectors)"
msgstr "分区 #%u 超出范围(最小起点是 %<PRIu64> 扇区)"

#: libfdisk/src/gpt.c:2703
#, fuzzy, c-format
msgid "Partition #%zu out of range (maximal end is %<PRIu64> sectors)"
msgstr "分区 #%u 超出范围(最小终点是 %<PRIu64> 扇区)"

#: libfdisk/src/gpt.c:2746
#, fuzzy, c-format
msgid "The number of the partition has to be smaller than %zu."
msgstr "已创建分区达到最大数量。"

#: libfdisk/src/gpt.c:2769
msgid "Cannot allocate memory!"
msgstr "无法分配内存！"

#: libfdisk/src/gpt.c:2799
#, c-format
msgid "Partition table length changed from %<PRIu32> to %<PRIu64>."
msgstr "分区表长度已从 %<PRIu32> 改为 %<PRIu64>。"

#: libfdisk/src/gpt.c:2908
#, c-format
msgid "The attributes on partition %zu changed to 0x%016<PRIx64>."
msgstr "分区 %zu 的属性已改为 0x%016<PRIx64>。"

#: libfdisk/src/gpt.c:2958
msgid "Enter GUID specific bit"
msgstr "输入 GUID 特定位"

#: libfdisk/src/gpt.c:2973
#, c-format
msgid "failed to toggle unsupported bit %lu"
msgstr "开/关不支持的位 %lu 失败"

#: libfdisk/src/gpt.c:2986
#, c-format
msgid "The GUID specific bit %d on partition %zu is enabled now."
msgstr "分区 %2$zu 上的 GUID 特定位 %1$d 现已启用。"

#: libfdisk/src/gpt.c:2987
#, c-format
msgid "The GUID specific bit %d on partition %zu is disabled now."
msgstr "分区 %2$zu 上的 GUID 特定位 %1$d 现已禁用。"

#: libfdisk/src/gpt.c:2991
#, c-format
msgid "The %s flag on partition %zu is enabled now."
msgstr "分区 %2$zu 上的标志 %1$s 现已启用。"

#: libfdisk/src/gpt.c:2992
#, c-format
msgid "The %s flag on partition %zu is disabled now."
msgstr "分区 %2$zu 上的标志 %1$s 现已禁用。"

#: libfdisk/src/gpt.c:3134
msgid "Type-UUID"
msgstr "类型-UUID"

#: libfdisk/src/gpt.c:3135
msgid "UUID"
msgstr "UUID"

#: libfdisk/src/gpt.c:3136 login-utils/chfn.c:156 login-utils/chfn.c:158
#: login-utils/chfn.c:324
msgid "Name"
msgstr "名称"

#: libfdisk/src/partition.c:848
msgid "Free space"
msgstr "剩余空间"

#: libfdisk/src/partition.c:1255
#, c-format
msgid "Failed to resize partition #%zu."
msgstr "调整分区 #%zu 的大小失败。"

#: libfdisk/src/parttype.c:258 misc-utils/findmnt.c:655
#: misc-utils/uuidparse.c:199 misc-utils/uuidparse.c:217 schedutils/chrt.c:205
#: schedutils/ionice.c:79 sys-utils/hwclock.c:268
msgid "unknown"
msgstr "未知"

#: libfdisk/src/sgi.c:46
msgid "SGI volhdr"
msgstr "SGI volhdr"

#: libfdisk/src/sgi.c:47
msgid "SGI trkrepl"
msgstr "SGI trkrepl"

#: libfdisk/src/sgi.c:48
msgid "SGI secrepl"
msgstr "SGI secrepl"

#: libfdisk/src/sgi.c:49
msgid "SGI raw"
msgstr "SGI raw"

#: libfdisk/src/sgi.c:50
msgid "SGI bsd"
msgstr "SGI bsd"

#: libfdisk/src/sgi.c:51
msgid "SGI sysv"
msgstr "SGI sysv"

#: libfdisk/src/sgi.c:52
msgid "SGI volume"
msgstr "SGI volume"

#: libfdisk/src/sgi.c:53
msgid "SGI efs"
msgstr "SGI efs"

#: libfdisk/src/sgi.c:54
msgid "SGI lvol"
msgstr "SGI lvol"

#: libfdisk/src/sgi.c:55
msgid "SGI rlvol"
msgstr "SGI rlvol"

#: libfdisk/src/sgi.c:56
msgid "SGI xfs"
msgstr "SGI xfs"

#: libfdisk/src/sgi.c:57
msgid "SGI xfslog"
msgstr "SGI xfslog"

#: libfdisk/src/sgi.c:58
msgid "SGI xlv"
msgstr "SGI xlv"

#: libfdisk/src/sgi.c:59
msgid "SGI xvm"
msgstr "SGI xvm"

#: libfdisk/src/sgi.c:61 libfdisk/src/sun.c:52
msgid "Linux native"
msgstr "Linux native"

#: libfdisk/src/sgi.c:158
msgid "SGI info created on second sector."
msgstr "在第二扇区创建了 SGI 信息。"

#: libfdisk/src/sgi.c:258
msgid "Detected an SGI disklabel with wrong checksum."
msgstr "检测到校验和错误的 sgi 磁盘标签。"

#: libfdisk/src/sgi.c:281 libfdisk/src/sun.c:783
msgid "Physical cylinders"
msgstr "物理柱面数"

#: libfdisk/src/sgi.c:286 libfdisk/src/sun.c:788
msgid "Extra sects/cyl"
msgstr "额外扇区/柱面"

#: libfdisk/src/sgi.c:296
msgid "Bootfile"
msgstr "启动文件"

#: libfdisk/src/sgi.c:394
msgid "Invalid bootfile!  The bootfile must be an absolute non-zero pathname, e.g. \"/unix\" or \"/unix.save\"."
msgstr "无效的启动文件！启动文件必须为绝对非零路径名，例如“/unix”或“/unix.save”。"

#: libfdisk/src/sgi.c:400
#, c-format
msgid "Name of bootfile is too long: %zu byte maximum."
msgid_plural "Name of bootfile is too long: %zu bytes maximum."
msgstr[0] "启动文件名过长：最多 %zu 个字节。"

#: libfdisk/src/sgi.c:407
msgid "Bootfile must have a fully qualified pathname."
msgstr "启动文件必须用完全限定路径名。"

#: libfdisk/src/sgi.c:413
msgid "Be aware that the bootfile is not checked for existence.  SGI's default is \"/unix\", and for backup \"/unix.save\"."
msgstr "注意，不会检查启动文件是否存在。SGI 默认值为“/unix”，备份为“/unix.save”。"

#: libfdisk/src/sgi.c:438
#, c-format
msgid "The current boot file is: %s"
msgstr "当前启动文件为：%s"

#: libfdisk/src/sgi.c:440
msgid "Enter of the new boot file"
msgstr "输入新启动文件的路径"

#: libfdisk/src/sgi.c:445
msgid "Boot file is unchanged."
msgstr "启动文件未改变。"

#: libfdisk/src/sgi.c:456
#, c-format
msgid "Bootfile has been changed to \"%s\"."
msgstr "启动文件已更改为“%s”。"

#: libfdisk/src/sgi.c:595
msgid "More than one entire disk entry present."
msgstr "存在超过一个整磁盘记录。"

#: libfdisk/src/sgi.c:602 libfdisk/src/sun.c:459
msgid "No partitions defined."
msgstr "未定义分区。"

#: libfdisk/src/sgi.c:612
msgid "IRIX likes it when partition 11 covers the entire disk."
msgstr "IRIX 偏向于让分区 11 覆盖整个磁盘。"

#: libfdisk/src/sgi.c:616
#, c-format
msgid "The entire disk partition should start at block 0, not at block %d."
msgstr "整磁盘分区应开始于块 0，而非块 %d。"

#: libfdisk/src/sgi.c:627
msgid "Partition 11 should cover the entire disk."
msgstr "分区 11 应覆盖整个磁盘。"

#: libfdisk/src/sgi.c:651
#, c-format
msgid "Partitions %d and %d overlap by %d sector."
msgid_plural "Partitions %d and %d overlap by %d sectors."
msgstr[0] "分区 %d 与 %d 重叠了 %d 个扇区。"

#: libfdisk/src/sgi.c:662 libfdisk/src/sgi.c:684
#, c-format
msgid "Unused gap of %8u sector: sector %8u"
msgid_plural "Unused gap of %8u sectors: sectors %8u-%u"
msgstr[0] "有未使用的 %8u 个扇区的间隙：扇区 %8u-%u"

#: libfdisk/src/sgi.c:697
msgid "The boot partition does not exist."
msgstr "启动分区不存在。"

#: libfdisk/src/sgi.c:701
msgid "The swap partition does not exist."
msgstr "交换分区不存在。"

#: libfdisk/src/sgi.c:705
msgid "The swap partition has no swap type."
msgstr "交换分区不是交换类型。"

#: libfdisk/src/sgi.c:708
msgid "You have chosen an unusual bootfile name."
msgstr "您选择了一个不常用的启动文件名。"

#: libfdisk/src/sgi.c:758
msgid "Partition overlap on the disk."
msgstr "磁盘上的分区重叠。"

#: libfdisk/src/sgi.c:843
msgid "Attempting to generate entire disk entry automatically."
msgstr "尝试自动生成整磁盘记录。"

#: libfdisk/src/sgi.c:848
msgid "The entire disk is already covered with partitions."
msgstr "整个磁盘已经被分区覆盖。"

#: libfdisk/src/sgi.c:852
msgid "You got a partition overlap on the disk. Fix it first!"
msgstr "磁盘上有重叠分区。请先修复它！"

#: libfdisk/src/sgi.c:874 libfdisk/src/sun.c:555
#, c-format
msgid "First %s"
msgstr "起始 %s"

#: libfdisk/src/sgi.c:898 libfdisk/src/sgi.c:948
msgid "It is highly recommended that the eleventh partition covers the entire disk and is of type 'SGI volume'."
msgstr "强烈建议第十一分区覆盖整个磁盘，并使用“SGI volume”类型。"

#: libfdisk/src/sgi.c:913 libfdisk/src/sun.c:650
#, c-format
msgid "Last %s or +%s or +size{K,M,G,T,P}"
msgstr "最后 %s 或+%s 或 +大小{K,M,G,T,P}"

#: libfdisk/src/sgi.c:984 libfdisk/src/sun.c:242
#, c-format
msgid "BLKGETSIZE ioctl failed on %s. Using geometry cylinder value of %llu. This value may be truncated for devices > 33.8 GB."
msgstr "对 %s 执行 BLKGETSIZE ioctl 失败。将使用几何 柱面 属性值 %llu。对于大于 33.8 GB 的设备，这个值可能被截短。"

#: libfdisk/src/sgi.c:1050
msgid "Created a new SGI disklabel."
msgstr "创建新的SGI 磁盘标签。"

#: libfdisk/src/sgi.c:1069
msgid "Sorry, only for non-empty partitions you can change the tag."
msgstr "抱歉，只有非空分区才能更改标志(tag)。"

#: libfdisk/src/sgi.c:1075
msgid "Consider leaving partition 9 as volume header (0), and partition 11 as entire volume (6), as IRIX expects it."
msgstr "考虑将分区 9 留作卷头(volume header) (0)，分区 11 作为整卷(6)，以符合 IRIX 规定。"

#: libfdisk/src/sgi.c:1084
msgid "It is highly recommended that the partition at offset 0 is of type \"SGI volhdr\", the IRIX system will rely on it to retrieve from its directory standalone tools like sash and fx. Only the \"SGI volume\" entire disk section may violate this. Are you sure about tagging this partition differently?"
msgstr "强烈建议偏移 0 处的分区设为“SGI volhdr”类型，IRIX 会依靠它从它的目录中获取独立的工具，如 sash 和 fx。只有“SGI volume”整磁盘部分(entire disk section)能违反这一规定。您确定要将这一分区标记成其他类型吗？"

#: libfdisk/src/sun.c:39
msgid "Unassigned"
msgstr "未分配"

#: libfdisk/src/sun.c:41
msgid "SunOS root"
msgstr "SunOS 根"

#: libfdisk/src/sun.c:42
msgid "SunOS swap"
msgstr "SunOS 交换"

#: libfdisk/src/sun.c:43
msgid "SunOS usr"
msgstr "SunOS usr"

#: libfdisk/src/sun.c:44
msgid "Whole disk"
msgstr "整盘"

#: libfdisk/src/sun.c:45
msgid "SunOS stand"
msgstr "SunOS stand"

#: libfdisk/src/sun.c:46
msgid "SunOS var"
msgstr "SunOS var"

#: libfdisk/src/sun.c:47
msgid "SunOS home"
msgstr "SunOS home"

#: libfdisk/src/sun.c:48
msgid "SunOS alt sectors"
msgstr "SunOS alt 扇区"

#: libfdisk/src/sun.c:49
msgid "SunOS cachefs"
msgstr "SunOS cachefs"

#: libfdisk/src/sun.c:50
msgid "SunOS reserved"
msgstr "SunOS 保留"

#: libfdisk/src/sun.c:130
msgid "Detected sun disklabel with wrong checksum. Probably you'll have to set all the values, e.g. heads, sectors, cylinders and partitions or force a fresh label (s command in main menu)"
msgstr "检测到校验和错误的 sun 磁盘标签。您可能要设置所有的值(如磁头、扇区、柱面和分区)或强制一个新标签(主菜单中的 s 命令)"

#: libfdisk/src/sun.c:147
#, c-format
msgid "Detected sun disklabel with wrong version [%d]."
msgstr "检测到带错误版本 [%d] 的 sun 磁盘标签 。"

#: libfdisk/src/sun.c:152
#, c-format
msgid "Detected sun disklabel with wrong vtoc.sanity [0x%08x]."
msgstr "检测到带错误的 vtoc.sanity [0x%08x] 的 sun 磁盘标签。"

#: libfdisk/src/sun.c:157
#, c-format
msgid "Detected sun disklabel with wrong vtoc.nparts [%u]."
msgstr "检测到带错误 vtoc.nparts [%u] 的 sun 磁盘标签。"

#: libfdisk/src/sun.c:162
msgid "Warning: Wrong values need to be fixed up and will be corrected by w(rite)"
msgstr "警告：错误值需要修复，并且将通过 w(写) 操作修正。"

#: libfdisk/src/sun.c:187
msgid "Heads"
msgstr "磁头"

#: libfdisk/src/sun.c:192
msgid "Sectors/track"
msgstr "扇区/磁道"

#: libfdisk/src/sun.c:293
msgid "Created a new Sun disklabel."
msgstr "创建新的 Sun 磁盘标签。"

#: libfdisk/src/sun.c:417
#, c-format
msgid "Partition %u doesn't end on cylinder boundary."
msgstr "分区 %u 未结束在柱面边界上。"

#: libfdisk/src/sun.c:436
#, c-format
msgid "Partition %u overlaps with others in sectors %u-%u."
msgstr "分区 %u 在扇区 %u-%u 与其他分区重叠。"

#: libfdisk/src/sun.c:464
#, c-format
msgid "Unused gap - sectors 0-%u."
msgstr "未使用的间隙 - 扇区 0-%u。"

#: libfdisk/src/sun.c:466 libfdisk/src/sun.c:472
#, c-format
msgid "Unused gap - sectors %u-%u."
msgstr "未使用的间隙 - 扇区 %u-%u。"

#: libfdisk/src/sun.c:534
msgid "Other partitions already cover the whole disk. Delete some/shrink them before retry."
msgstr "其他分区已覆盖了整个磁盘。删除几个分区或压缩它们，然后重试。"

#: libfdisk/src/sun.c:551
msgid "It is highly recommended that the third partition covers the whole disk and is of type `Whole disk'"
msgstr "强烈建议让第三个分区覆盖整个磁盘，并设为“整盘”类型"

#: libfdisk/src/sun.c:593
#, c-format
msgid "Aligning the first sector from %u to %u to be on cylinder boundary."
msgstr "将把从 %u 到 %u 的首个扇区对齐到柱面边界。"

#: libfdisk/src/sun.c:621
#, c-format
msgid "Sector %d is already allocated"
msgstr "扇区 %d 已分配"

#: libfdisk/src/sun.c:696
#, c-format
msgid ""
"You haven't covered the whole disk with the 3rd partition, but your value\n"
"%lu %s covers some other partition. Your entry has been changed\n"
"to %lu %s"
msgstr ""
"您没有使第三个分区覆盖整个磁盘，但是值 %lu %s 覆盖了其他分区。\n"
"您的记录已经更改为 %lu %s"

#: libfdisk/src/sun.c:739
#, c-format
msgid "If you want to maintain SunOS/Solaris compatibility, consider leaving this partition as Whole disk (5), starting at 0, with %u sectors"
msgstr "如果您想与 SunOS/Solaris 兼容，请保持此分区为 整盘 (5)，以 0 开始，大小为 %u 个扇区"

#: libfdisk/src/sun.c:763
msgid "Label ID"
msgstr "标签 ID"

#: libfdisk/src/sun.c:768
msgid "Volume ID"
msgstr "卷 ID"

#: libfdisk/src/sun.c:778
msgid "Alternate cylinders"
msgstr "备用柱面数"

#: libfdisk/src/sun.c:884
msgid "Number of alternate cylinders"
msgstr "备用柱面的数量"

#: libfdisk/src/sun.c:909
msgid "Extra sectors per cylinder"
msgstr "每个柱面的额外扇区数"

#: libfdisk/src/sun.c:933
msgid "Interleave factor"
msgstr "交错系数"

#: libfdisk/src/sun.c:957
msgid "Rotation speed (rpm)"
msgstr "转速(转/分)"

#: libfdisk/src/sun.c:981
msgid "Number of physical cylinders"
msgstr "物理柱面数"

#: libfdisk/src/sun.c:1046
msgid ""
"Consider leaving partition 3 as Whole disk (5),\n"
"as SunOS/Solaris expects it and even Linux likes it.\n"
msgstr ""
"考虑保持分区 3 为 整盘 (5)，\n"
"这是 SunOS/Solaris 的规定，Linux 也建议这么做。\n"

#: libfdisk/src/sun.c:1057
msgid ""
"It is highly recommended that the partition at offset 0\n"
"is UFS, EXT2FS filesystem or SunOS swap. Putting Linux swap\n"
"there may destroy your partition table and bootblock.\n"
"Are you sure you want to tag the partition as Linux swap?"
msgstr ""
"强烈建议偏移 0 处的分区为 UFS、EXT2FS 文件系统或\n"
"SunOS 交换分区。将 Linux 交换分区放在那里可能毁坏分区表\n"
"和启动锁。\n"
"您确信要把该分区标记为 Linux 交换分区吗？"

#: libmount/src/context.c:2377
#, fuzzy, c-format
msgid "operation failed: %m"
msgstr "readlink 失败：%s"

#: libmount/src/context_mount.c:1335
#, c-format
msgid "WARNING: failed to apply propagation flags"
msgstr "警告：应用传播标志失败"

#: libmount/src/context_mount.c:1345
#, fuzzy, c-format
msgid "WARNING: device write-protected, mounted read-only"
msgstr "%s 写保护，将以只读方式挂载"

#: libmount/src/context_mount.c:1359
#, c-format
msgid "operation permitted for root only"
msgstr ""

#: libmount/src/context_mount.c:1363
#, c-format
msgid "%s is already mounted"
msgstr "%s 已经挂载"

#: libmount/src/context_mount.c:1369
#, fuzzy, c-format
msgid "can't find in %s"
msgstr "在 %2$s 中找不到 %1$s"

#: libmount/src/context_mount.c:1372
#, fuzzy, c-format
msgid "can't find mount point in %s"
msgstr "在 %2$s 中找不到挂载点 %1$s"

#: libmount/src/context_mount.c:1375
#, c-format
msgid "can't find mount source %s in %s"
msgstr "在 %2$s 中找不到挂载源 %1$s"

#: libmount/src/context_mount.c:1380
#, c-format
msgid "more filesystems detected on %s; use -t <type> or wipefs(8)"
msgstr ""

#: libmount/src/context_mount.c:1385
#, fuzzy, c-format
msgid "failed to determine filesystem type"
msgstr "%s：确定源失败"

#: libmount/src/context_mount.c:1386
#, fuzzy, c-format
msgid "no filesystem type specified"
msgstr "未指定文件名"

#: libmount/src/context_mount.c:1393
#, c-format
msgid "can't find %s"
msgstr "找不到 %s"

#: libmount/src/context_mount.c:1395
#, fuzzy, c-format
msgid "no mount source specified"
msgstr "未指定挂载点"

#: libmount/src/context_mount.c:1401
#, fuzzy, c-format
msgid "failed to parse mount options: %m"
msgstr "解析挂臷选项失败"

#: libmount/src/context_mount.c:1402
#, c-format
msgid "failed to parse mount options"
msgstr "解析挂臷选项失败"

#: libmount/src/context_mount.c:1406
#, fuzzy, c-format
msgid "failed to setup loop device for %s"
msgstr "%s：设置回环设备失败"

#: libmount/src/context_mount.c:1410
#, fuzzy, c-format
msgid "overlapping loop device exists for %s"
msgstr "%s: 重叠的回环设备已存在"

#: libmount/src/context_mount.c:1414 libmount/src/context_umount.c:1076
#, fuzzy, c-format
msgid "locking failed"
msgstr "关闭 %s 失败"

#: libmount/src/context_mount.c:1417
#, fuzzy, c-format
msgid "mount failed: %m"
msgstr "挂载失败"

#: libmount/src/context_mount.c:1427
#, fuzzy, c-format
msgid "filesystem was mounted, but failed to update userspace mount table"
msgstr "%s：文件系统已卸载，但 mount(8) 失败"

#: libmount/src/context_mount.c:1432
#, fuzzy, c-format
msgid "filesystem was mounted, but any subsequent operation failed: %m"
msgstr "%s：文件系统已卸载，但 mount(8) 失败"

#: libmount/src/context_mount.c:1450 libmount/src/context_mount.c:1507
#, fuzzy, c-format
msgid "mount point is not a directory"
msgstr "挂载点 %s 不是目录"

#: libmount/src/context_mount.c:1452 login-utils/newgrp.c:227
#, c-format
msgid "permission denied"
msgstr "权限不足"

#: libmount/src/context_mount.c:1454
#, c-format
msgid "must be superuser to use mount"
msgstr "必须以超级用户身份使用 mount"

#: libmount/src/context_mount.c:1464
#, fuzzy, c-format
msgid "mount point is busy"
msgstr "mount：%s 忙"

#: libmount/src/context_mount.c:1477
#, fuzzy, c-format
msgid "%s already mounted on %s"
msgstr "mount：%s 已挂载于 %s\n"

#: libmount/src/context_mount.c:1483
#, fuzzy, c-format
msgid "%s already mounted or mount point busy"
msgstr "%s 已经挂载或 %s 忙"

#: libmount/src/context_mount.c:1489
#, fuzzy, c-format
msgid "mount point does not exist"
msgstr "挂载点 %s 不存在"

#: libmount/src/context_mount.c:1492
#, fuzzy, c-format
msgid "mount point is a symbolic link to nowhere"
msgstr "挂载点 %s 是一个没有目标的符号链接"

#: libmount/src/context_mount.c:1497
#, c-format
msgid "special device %s does not exist"
msgstr "特殊设备 %s 不存在"

#: libmount/src/context_mount.c:1500 libmount/src/context_mount.c:1516
#: libmount/src/context_mount.c:1600 libmount/src/context_mount.c:1623
#, fuzzy, c-format
msgid "mount(2) system call failed: %m"
msgstr "mount(2) 失败"

#: libmount/src/context_mount.c:1512
#, c-format
msgid "special device %s does not exist (a path prefix is not a directory)"
msgstr "特殊设备 %s 不存在(路径前缀不是目录)"

#: libmount/src/context_mount.c:1524
#, fuzzy, c-format
msgid "mount point not mounted or bad option"
msgstr "mount：%s 未挂载或选项错误"

#: libmount/src/context_mount.c:1526
#, fuzzy, c-format
msgid "not mount point or bad option"
msgstr "%s 不是一个挂载点或选项有误"

#: libmount/src/context_mount.c:1529
#, fuzzy, c-format
msgid "bad option; moving a mount residing under a shared mount is unsupported"
msgstr "选项错误。注意，不支持移动位于共享挂载内的挂载。"

#: libmount/src/context_mount.c:1533
#, fuzzy, c-format
msgid "bad option; for several filesystems (e.g. nfs, cifs) you might need a /sbin/mount.<type> helper program"
msgstr ""
"       (对某些文件系统(如 nfs、cifs) 您可能需要\n"
"       一款 /sbin/mount.<类型> 助手程序)"

#: libmount/src/context_mount.c:1537
#, fuzzy, c-format
msgid "wrong fs type, bad option, bad superblock on %s, missing codepage or helper program, or other error"
msgstr ""
"文件系统类型错误、选项错误、%s 上有坏超级块、\n"
"       缺少代码页或助手程序，或其他错误"

#: libmount/src/context_mount.c:1544
#, c-format
msgid "mount table full"
msgstr "挂载表满"

#: libmount/src/context_mount.c:1549
#, fuzzy, c-format
msgid "can't read superblock on %s"
msgstr "%s：不能读超级块"

#: libmount/src/context_mount.c:1556
#, c-format
msgid "unknown filesystem type '%s'"
msgstr "未知的文件系统类型“%s”"

#: libmount/src/context_mount.c:1559
#, c-format
msgid "unknown filesystem type"
msgstr "未知的文件系统类型"

#: libmount/src/context_mount.c:1568
#, c-format
msgid "%s is not a block device, and stat(2) fails?"
msgstr "%s 不是块设备，而且 stat(2) 失败？"

#: libmount/src/context_mount.c:1571
#, fuzzy, c-format
msgid "the kernel does not recognize %s as a block device; maybe \"modprobe driver\" is necessary"
msgstr ""
"内核无法将 %s 识别为块设备\n"
"       (试试“modprobe driver”？)"

#: libmount/src/context_mount.c:1574
#, fuzzy, c-format
msgid "%s is not a block device; try \"-o loop\""
msgstr "%s 不是块设备(用 `-o loop' 试试？)"

#: libmount/src/context_mount.c:1576
#, fuzzy, c-format
msgid "%s is not a block device"
msgstr "%s 不是一个块设备"

#: libmount/src/context_mount.c:1583
#, c-format
msgid "%s is not a valid block device"
msgstr "%s 不是一个有效的块设备"

#: libmount/src/context_mount.c:1591
#, c-format
msgid "cannot mount %s read-only"
msgstr "无法以只读方式挂载 %s"

#: libmount/src/context_mount.c:1593
#, fuzzy, c-format
msgid "%s is write-protected but explicit read-write mode requested"
msgstr "%s 是写保护的，但指明了“-w”标志"

#: libmount/src/context_mount.c:1595
#, c-format
msgid "cannot remount %s read-write, is write-protected"
msgstr "无法以读写方式重新挂载 %s，它是写保护的"

#: libmount/src/context_mount.c:1597
#, fuzzy, c-format
msgid "bind %s failed"
msgstr "%s 失败"

#: libmount/src/context_mount.c:1608
#, c-format
msgid "no medium found on %s"
msgstr "在 %s 上找不到媒体"

#: libmount/src/context_mount.c:1615
#, fuzzy, c-format
msgid "cannot mount; probably corrupted filesystem on %s"
msgstr "将不会尝试在“%s”上创建文件系统"

#: libmount/src/context_umount.c:1072 libmount/src/context_umount.c:1110
#, fuzzy, c-format
msgid "not mounted"
msgstr "%s：未挂载"

#: libmount/src/context_umount.c:1080
#, fuzzy, c-format
msgid "umount failed: %m"
msgstr "挂载失败"

#: libmount/src/context_umount.c:1089
#, fuzzy, c-format
msgid "filesystem was unmounted, but failed to update userspace mount table"
msgstr "%s：文件系统已卸载，但 mount(8) 失败"

#: libmount/src/context_umount.c:1094
#, fuzzy, c-format
msgid "filesystem was unmounted, but any subsequent operation failed: %m"
msgstr "%s：文件系统已卸载，但 mount(8) 失败"

#: libmount/src/context_umount.c:1107
#, fuzzy, c-format
msgid "invalid block device"
msgstr "%s：无效的块设备"

#: libmount/src/context_umount.c:1113
#, fuzzy, c-format
msgid "can't write superblock"
msgstr "%s：无法写超级块"

#: libmount/src/context_umount.c:1116
#, fuzzy, c-format
msgid "target is busy"
msgstr "目标存在"

#: libmount/src/context_umount.c:1119
#, fuzzy, c-format
msgid "no mount point specified"
msgstr "未指定挂载点"

#: libmount/src/context_umount.c:1122
#, fuzzy, c-format
msgid "must be superuser to unmount"
msgstr "%s：必须以超级用户身份卸载"

#: libmount/src/context_umount.c:1125
#, fuzzy, c-format
msgid "block devices are not permitted on filesystem"
msgstr "%s：文件系统不允许块设备"

#: libmount/src/context_umount.c:1128
#, fuzzy, c-format
msgid "umount(2) system call failed: %m"
msgstr "mount(2) 失败"

#: lib/pager.c:112
#, c-format
msgid "waitpid failed (%s)"
msgstr "waitpid 失败(%s)"

#: lib/path.c:239 sys-utils/lscpu.c:1760
msgid "failed to callocate cpu set"
msgstr "分配(callocate) CPU 组 失败"

#: lib/path.c:243
#, c-format
msgid "failed to parse CPU list %s"
msgstr "解析 CPU 列表 %s 失败"

#: lib/path.c:246
#, c-format
msgid "failed to parse CPU mask %s"
msgstr "解析 CPU 掩码 %s 失败"

#: lib/plymouth-ctrl.c:73
#, fuzzy
msgid "cannot open UNIX socket"
msgstr "打不开 UNIX 套接字"

#: lib/plymouth-ctrl.c:79
#, fuzzy
msgid "cannot set option for UNIX socket"
msgstr "无法设置 UNIX 套接字选项"

#: lib/plymouth-ctrl.c:90
#, fuzzy
msgid "cannot connect on UNIX socket"
msgstr "无法连接 UNIX 套接字"

#: lib/plymouth-ctrl.c:128
#, c-format
msgid "the plymouth request %c is not implemented"
msgstr "plymouth 请求 %c 没有实现"

#: lib/randutils.c:186
#, fuzzy
msgid "getrandom() function"
msgstr "libc 伪随机函数"

#: lib/randutils.c:199
msgid "libc pseudo-random functions"
msgstr "libc 伪随机函数"

#: lib/swapprober.c:17 lib/swapprober.c:30
#, c-format
msgid "%s: unable to probe device"
msgstr "%s：无法探测设备"

#: lib/swapprober.c:32
#, c-format
msgid "%s: ambiguous probing result; use wipefs(8)"
msgstr "%s：探测结果有歧义；请使用 wipefs(8)"

#: lib/swapprober.c:34
#, c-format
msgid "%s: not a valid swap partition"
msgstr "%s：不是有效的交换分区"

#: lib/swapprober.c:41
#, c-format
msgid "%s: unsupported swap version '%s'"
msgstr "%s：不支持的 swap 版本“%s”"

#: lib/timeutils.c:459
msgid "format_iso_time: buffer overflow."
msgstr ""

#: lib/timeutils.c:477 lib/timeutils.c:501
#, fuzzy, c-format
msgid "time %ld is out of range."
msgstr "值超出范围。"

#: login-utils/chfn.c:96 login-utils/chsh.c:74
#, c-format
msgid " %s [options] [<username>]\n"
msgstr " %s [选项] [<用户名>]\n"

#: login-utils/chfn.c:99
msgid "Change your finger information.\n"
msgstr "更改您的手指信息。\n"

#: login-utils/chfn.c:102
msgid " -f, --full-name <full-name>  real name\n"
msgstr " -f, --full-name <全名>       真实姓名\n"

#: login-utils/chfn.c:103
msgid " -o, --office <office>        office number\n"
msgstr " -o, --office <办公>          办公号码\n"

#: login-utils/chfn.c:104
msgid " -p, --office-phone <phone>   office phone number\n"
msgstr " -p, --office-phone <电话>    办公电话\n"

#: login-utils/chfn.c:105
msgid " -h, --home-phone <phone>     home phone number\n"
msgstr " -h, --home-phone <电话>      住宅电话\n"

#: login-utils/chfn.c:123
#, c-format
msgid "field %s is too long"
msgstr "字段 %s 过长"

#: login-utils/chfn.c:127 login-utils/chsh.c:236
#, c-format
msgid "%s: has illegal characters"
msgstr "%s：含有非法字符"

#: login-utils/chfn.c:156 login-utils/chfn.c:162 login-utils/chfn.c:168
#: login-utils/chfn.c:174
#, c-format
msgid "login.defs forbids setting %s"
msgstr "login.defs 禁止设置 %s"

#: login-utils/chfn.c:162 login-utils/chfn.c:164 login-utils/chfn.c:326
msgid "Office"
msgstr "办公"

#: login-utils/chfn.c:168 login-utils/chfn.c:170 login-utils/chfn.c:328
msgid "Office Phone"
msgstr "办公电话"

#: login-utils/chfn.c:174 login-utils/chfn.c:176 login-utils/chfn.c:330
msgid "Home Phone"
msgstr "住宅电话"

#: login-utils/chfn.c:194 login-utils/chsh.c:187
msgid "cannot handle multiple usernames"
msgstr ""

#: login-utils/chfn.c:248
msgid "Aborted."
msgstr "已中止。"

#: login-utils/chfn.c:311
#, c-format
msgid "%s: CHFN_RESTRICT has unexpected value: %s"
msgstr "%s: CHFN_RESTRICT 的值异常：%s"

#: login-utils/chfn.c:313
#, c-format
msgid "%s: CHFN_RESTRICT does not allow any changes"
msgstr "%s: CHFN_RESTRICT 不允许更改"

#: login-utils/chfn.c:396
#, c-format
msgid "Finger information *NOT* changed.  Try again later.\n"
msgstr "Finger 信息*没有*更改。请稍后重试。\n"

#: login-utils/chfn.c:400
#, c-format
msgid "Finger information changed.\n"
msgstr "Finger 信息已更改。\n"

#: login-utils/chfn.c:425 login-utils/chsh.c:273
#, c-format
msgid "you (user %d) don't exist."
msgstr "您(用户 %d)不存在。"

#: login-utils/chfn.c:431 login-utils/chsh.c:278 login-utils/libuser.c:59
#, c-format
msgid "user \"%s\" does not exist."
msgstr "用户“%s”不存在。"

#: login-utils/chfn.c:437 login-utils/chsh.c:284
msgid "can only change local entries"
msgstr "只能更改本地记录"

#: login-utils/chfn.c:450
#, c-format
msgid "%s is not authorized to change the finger info of %s"
msgstr "%s 未得到授权更改 %s 的 finger 信息"

#: login-utils/chfn.c:452 login-utils/chsh.c:300
msgid "Unknown user context"
msgstr "未知用户环境(context)"

#: login-utils/chfn.c:458 login-utils/chsh.c:306
#, c-format
msgid "can't set default context for %s"
msgstr "无法设置 %s 默认环境(context)"

#: login-utils/chfn.c:469
msgid "running UID doesn't match UID of user we're altering, change denied"
msgstr "运行中的 UID 与要改变的用户的 UID 不匹配，更改被拒绝"

#: login-utils/chfn.c:473
#, c-format
msgid "Changing finger information for %s.\n"
msgstr "正在更改 %s 的 finger 信息。\n"

#: login-utils/chfn.c:487
#, c-format
msgid "Finger information not changed.\n"
msgstr "Finger 信息未更改。\n"

#: login-utils/chsh.c:77
msgid "Change your login shell.\n"
msgstr "更改您的登录 shell。\n"

#: login-utils/chsh.c:80
msgid " -s, --shell <shell>  specify login shell\n"
msgstr " -s, --shell <shell>  指定登录 shell\n"

#: login-utils/chsh.c:81
msgid " -l, --list-shells    print list of shells and exit\n"
msgstr " -l, --list-shells    打印 shell 列表并退出\n"

#: login-utils/chsh.c:230
msgid "shell must be a full path name"
msgstr "shell 必须为完整路径名称"

#: login-utils/chsh.c:232
#, c-format
msgid "\"%s\" does not exist"
msgstr "“%s”不存在"

#: login-utils/chsh.c:234
#, c-format
msgid "\"%s\" is not executable"
msgstr "“%s”不可执行"

#: login-utils/chsh.c:240
#, c-format
msgid "Warning: \"%s\" is not listed in %s."
msgstr "警告：“%s”未在 %s 中列出。"

#: login-utils/chsh.c:244 login-utils/chsh.c:248
#, c-format
msgid ""
"\"%s\" is not listed in %s.\n"
"Use %s -l to see list."
msgstr ""
"“%s”未列在 %s 中。\n"
"请使用 %s -l 查看列表。"

#: login-utils/chsh.c:299
#, c-format
msgid "%s is not authorized to change the shell of %s"
msgstr "%s 无权更改 %s 的 shell"

#: login-utils/chsh.c:325
msgid "running UID doesn't match UID of user we're altering, shell change denied"
msgstr "运行 UID 与要更改的用户的 UID 不匹配，更改 shell 被拒绝"

#: login-utils/chsh.c:330
#, c-format
msgid "your shell is not in %s, shell change denied"
msgstr "您的 shell 不在 %s 中，更改 shell 被拒绝"

#: login-utils/chsh.c:334
#, c-format
msgid "Changing shell for %s.\n"
msgstr "正在更改 %s 的 shell。\n"

#: login-utils/chsh.c:342
msgid "New shell"
msgstr "新 shell"

#: login-utils/chsh.c:350
msgid "Shell not changed."
msgstr "shell 未更改。"

#: login-utils/chsh.c:355
msgid "Shell *NOT* changed.  Try again later."
msgstr "Shell *未* 更改。请稍后重试。"

#: login-utils/chsh.c:359
msgid ""
"setpwnam failed\n"
"Shell *NOT* changed.  Try again later."
msgstr ""
"setpwnam 失败\n"
"Shell *未* 更改。请稍后重试。"

#: login-utils/chsh.c:363
#, c-format
msgid "Shell changed.\n"
msgstr "shell 已更改。\n"

#: login-utils/islocal.c:96
#, c-format
msgid "Usage: %s <passwordfile> <username>...\n"
msgstr "用法：%s <密码文件> <用户名>...\n"

#: login-utils/last.c:169 login-utils/lslogins.c:1217 sys-utils/dmesg.c:1269
#: sys-utils/lsipc.c:269
#, c-format
msgid "unknown time format: %s"
msgstr "未知时间格式: %s"

#: login-utils/last.c:276 login-utils/last.c:284
#, c-format
msgid "Interrupted %s"
msgstr "中断的 %s"

#: login-utils/last.c:435 login-utils/last.c:446 login-utils/last.c:892
msgid "preallocation size exceeded"
msgstr "超过了预分配大小"

#: login-utils/last.c:572
#, c-format
msgid " %s [options] [<username>...] [<tty>...]\n"
msgstr " %s [选项] [<用户名>...] [<tty>...]\n"

#: login-utils/last.c:575
msgid "Show a listing of last logged in users.\n"
msgstr "显示上次登录用户的列表。\n"

#: login-utils/last.c:578
msgid " -<number>            how many lines to show\n"
msgstr " -<数字>              显示行数\n"

#: login-utils/last.c:579
msgid " -a, --hostlast       display hostnames in the last column\n"
msgstr " -a, --hostlast       最后一列显示主机名\n"

#: login-utils/last.c:580
msgid " -d, --dns            translate the IP number back into a hostname\n"
msgstr " -d, --dns            将 IP 号转换回主机名\n"

#: login-utils/last.c:582
#, c-format
msgid " -f, --file <file>    use a specific file instead of %s\n"
msgstr " -F, --file <文件>    用指定文件代替 %s\n"

#: login-utils/last.c:583
msgid " -F, --fulltimes      print full login and logout times and dates\n"
msgstr " -F, --fulltimes      打印完整的登录和注销时间和日期\n"

#: login-utils/last.c:584
msgid " -i, --ip             display IP numbers in numbers-and-dots notation\n"
msgstr " -i, --ip             以数字和点的形式显示 IP 号\n"

#: login-utils/last.c:585
msgid " -n, --limit <number> how many lines to show\n"
msgstr " -n, --limit <数字>   要显示的行数\n"

#: login-utils/last.c:586
msgid " -R, --nohostname     don't display the hostname field\n"
msgstr " -R, --nohostname     不显示主机名字段\n"

#: login-utils/last.c:587
msgid " -s, --since <time>   display the lines since the specified time\n"
msgstr " -s, --since <时间>   显示从指定时间起的行\n"

#: login-utils/last.c:588
msgid " -t, --until <time>   display the lines until the specified time\n"
msgstr " -t, --until <时间>   显示到指定时间为止的行\n"

#: login-utils/last.c:589
msgid " -p, --present <time> display who were present at the specified time\n"
msgstr " -p, --present <时间> 显示在指定时间谁在场(present)\n"

#: login-utils/last.c:590
msgid " -w, --fullnames      display full user and domain names\n"
msgstr " -w, --fullnames      显示完整的用户名和域名\n"

#: login-utils/last.c:591
msgid " -x, --system         display system shutdown entries and run level changes\n"
msgstr " -x, --system         显示系统关机项和运行级别更改\n"

#: login-utils/last.c:592
msgid ""
"     --time-format <format>  show timestamps in the specified <format>:\n"
"                               notime|short|full|iso\n"
msgstr ""
"     --time-format <格式>    以指定<格式>显示时间戳：\n"
"                               notime|short|full|iso\n"

#: login-utils/last.c:893
#, fuzzy, c-format
msgid ""
"\n"
"%s begins %s\n"
msgstr ""
"\n"
"%s 开始 %s"

#: login-utils/last.c:972 term-utils/scriptreplay.c:65
#: term-utils/scriptreplay.c:69
msgid "failed to parse number"
msgstr "解析数字失败"

#: login-utils/last.c:993 login-utils/last.c:998 login-utils/last.c:1003
#: sys-utils/rtcwake.c:503
#, c-format
msgid "invalid time value \"%s\""
msgstr "无效的时间值\"%s\""

#: login-utils/libuser.c:29 login-utils/libuser.c:31
msgid "Couldn't drop group privileges"
msgstr "无法丢弃(drop)组优先级"

#: login-utils/libuser.c:47
#, c-format
msgid "libuser initialization failed: %s."
msgstr "libuser 初始化失败：%s。"

#: login-utils/libuser.c:52
msgid "changing user attribute failed"
msgstr "更改用户属性失败"

#: login-utils/libuser.c:66
#, c-format
msgid "user attribute not changed: %s"
msgstr "用户属性未更改：%s"

#: login-utils/login.c:291
#, c-format
msgid "FATAL: can't reopen tty: %m"
msgstr "致命：无法重新打开 tty：%m"

#: login-utils/login.c:297
#, c-format
msgid "FATAL: %s is not a terminal"
msgstr "致命：%s 不是终端"

#: login-utils/login.c:315
#, c-format
msgid "chown (%s, %lu, %lu) failed: %m"
msgstr "chown (%s, %lu, %lu) 失败：%m"

#: login-utils/login.c:319
#, c-format
msgid "chmod (%s, %u) failed: %m"
msgstr "chmod (%s, %u) 失败：%m"

#: login-utils/login.c:380
msgid "FATAL: bad tty"
msgstr "致命：坏的 tty"

#: login-utils/login.c:398
#, c-format
msgid "FATAL: %s: change permissions failed: %m"
msgstr "致命：%s：更改权限失败：%m"

#: login-utils/login.c:524
#, c-format
msgid "Last login: %.*s "
msgstr "上次登录：%.*s "

#: login-utils/login.c:526
#, c-format
msgid "from %.*s\n"
msgstr "来自 %.*s\n"

#: login-utils/login.c:529
#, c-format
msgid "on %.*s\n"
msgstr "于 %.*s\n"

#: login-utils/login.c:547
msgid "write lastlog failed"
msgstr "写 lastlog 失败"

#: login-utils/login.c:638
#, c-format
msgid "DIALUP AT %s BY %s"
msgstr "DIALUP AT %s BY %s"

#: login-utils/login.c:643
#, c-format
msgid "ROOT LOGIN ON %s FROM %s"
msgstr "ROOT LOGIN ON %s FROM %s"

#: login-utils/login.c:646
#, c-format
msgid "ROOT LOGIN ON %s"
msgstr "ROOT LOGIN ON %s"

#: login-utils/login.c:649
#, c-format
msgid "LOGIN ON %s BY %s FROM %s"
msgstr "LOGIN ON %s BY %s FROM %s"

#: login-utils/login.c:652
#, c-format
msgid "LOGIN ON %s BY %s"
msgstr "LOGIN ON %s BY %s"

#: login-utils/login.c:686
msgid "login: "
msgstr "登录："

#: login-utils/login.c:717
#, c-format
msgid "PAM failure, aborting: %s"
msgstr "PAM 失败，将中止：%s"

#: login-utils/login.c:718
#, c-format
msgid "Couldn't initialize PAM: %s"
msgstr "无法初始化 PAM：%s"

#: login-utils/login.c:789
#, c-format
msgid "FAILED LOGIN %u FROM %s FOR %s, %s"
msgstr "FAILED LOGIN %u FROM %s FOR %s, %s"

#: login-utils/login.c:797 login-utils/sulogin.c:1013
#, c-format
msgid ""
"Login incorrect\n"
"\n"
msgstr ""
"登录不正确\n"
"\n"

#: login-utils/login.c:812
#, c-format
msgid "TOO MANY LOGIN TRIES (%u) FROM %s FOR %s, %s"
msgstr "TOO MANY LOGIN TRIES (%u) FROM %s FOR %s, %s"

#: login-utils/login.c:818
#, c-format
msgid "FAILED LOGIN SESSION FROM %s FOR %s, %s"
msgstr "FAILED LOGIN SESSION FROM %s FOR %s, %s"

#: login-utils/login.c:826
#, c-format
msgid ""
"\n"
"Login incorrect\n"
msgstr ""
"\n"
"登录不正确\n"

#: login-utils/login.c:854 login-utils/login.c:1241 login-utils/login.c:1264
msgid ""
"\n"
"Session setup problem, abort."
msgstr ""
"\n"
"会话设置问题，中止。"

#: login-utils/login.c:855
#, c-format
msgid "NULL user name in %s:%d. Abort."
msgstr "%s:%d 中是空(NULL)用户名。中止。"

#: login-utils/login.c:994
#, c-format
msgid "TIOCSCTTY failed: %m"
msgstr "TIOCSCTTY 失败：%m"

#: login-utils/login.c:1098
#, fuzzy, c-format
msgid " %s [-p] [-h <host>] [-H] [[-f] <username>]\n"
msgstr "用法：login [-p] [-h <主机>] [-H] [[-f] <用户名>]\n"

#: login-utils/login.c:1100
msgid "Begin a session on the system.\n"
msgstr "在此系统上开始一次会话。\n"

#: login-utils/login.c:1103
#, fuzzy
msgid " -p             do not destroy the environment"
msgstr " -f           不分割长行\n"

#: login-utils/login.c:1104
msgid " -f             skip a second login authentication"
msgstr ""

#: login-utils/login.c:1105
msgid " -h <host>      hostname to be used for utmp logging"
msgstr ""

#: login-utils/login.c:1106
#, fuzzy
msgid " -H             suppress hostname in the login prompt"
msgstr " -u          屏蔽下划线\n"

#: login-utils/login.c:1151
#, fuzzy, c-format
msgid "%s: timed out after %u seconds"
msgstr "%u 秒后超时"

#: login-utils/login.c:1184
#, c-format
msgid "login: -h is for superuser only\n"
msgstr "login：-h 是超级用户专用选项\n"

#: login-utils/login.c:1242
#, c-format
msgid "Invalid user name \"%s\" in %s:%d. Abort."
msgstr "%2$s:%3$d 中是无效用户名“%1$s”。中止。"

#: login-utils/login.c:1263
#, c-format
msgid "groups initialization failed: %m"
msgstr "组初始化失败：%m"

#: login-utils/login.c:1288
msgid "setgid() failed"
msgstr "setgid() 失败"

#: login-utils/login.c:1318
#, c-format
msgid "You have new mail.\n"
msgstr "有您的新邮件。\n"

#: login-utils/login.c:1320
#, c-format
msgid "You have mail.\n"
msgstr "有您的邮件。\n"

#: login-utils/login.c:1334
msgid "setuid() failed"
msgstr "setuid() 失败"

#: login-utils/login.c:1340 login-utils/sulogin.c:729
#, c-format
msgid "%s: change directory failed"
msgstr "%s：更改目录失败"

#: login-utils/login.c:1347 login-utils/sulogin.c:730
#, c-format
msgid "Logging in with home = \"/\".\n"
msgstr "以 home = “/” 登录。\n"

#: login-utils/login.c:1376
msgid "couldn't exec shell script"
msgstr "无法执行(exec) shell 脚本"

#: login-utils/login.c:1378
msgid "no shell"
msgstr "无 shell"

#: login-utils/logindefs.c:213
#, c-format
msgid "%s: %s contains invalid numerical value: %s"
msgstr "%s：%s 包含无效的数字值：%s"

#: login-utils/logindefs.c:383
msgid "hush login status: restore original IDs failed"
msgstr "静默(hush)登录状态：恢复原 ID 失败"

#: login-utils/lslogins.c:208 sys-utils/lscpu.c:1436 sys-utils/lscpu.c:1446
#: sys-utils/lsmem.c:268
msgid "no"
msgstr "否"

#: login-utils/lslogins.c:217 misc-utils/lsblk.c:186
msgid "user name"
msgstr "用户名"

#: login-utils/lslogins.c:217
msgid "Username"
msgstr "用户名"

#: login-utils/lslogins.c:218 sys-utils/renice.c:54
msgid "user ID"
msgstr "用户 ID"

#: login-utils/lslogins.c:219
msgid "password not required"
msgstr "无需密码"

#: login-utils/lslogins.c:219
msgid "Password not required"
msgstr "无需密码"

#: login-utils/lslogins.c:220
msgid "login by password disabled"
msgstr "已禁止使用密码登录"

#: login-utils/lslogins.c:220
msgid "Login by password disabled"
msgstr "已禁止使用密码登录"

#: login-utils/lslogins.c:221
msgid "password defined, but locked"
msgstr "定义了密码，但已锁定"

#: login-utils/lslogins.c:221
msgid "Password is locked"
msgstr "密码已锁定"

#: login-utils/lslogins.c:222
msgid "log in disabled by nologin(8) or pam_nologin(8)"
msgstr "nologin(8) 或 pam_nologin(8) 禁止了登录"

#: login-utils/lslogins.c:222
msgid "No login"
msgstr "不能登录"

#: login-utils/lslogins.c:223
msgid "primary group name"
msgstr "主组名"

#: login-utils/lslogins.c:223
msgid "Primary group"
msgstr "主组"

#: login-utils/lslogins.c:224
msgid "primary group ID"
msgstr " 主组 ID"

#: login-utils/lslogins.c:225
msgid "supplementary group names"
msgstr "附属组名"

#: login-utils/lslogins.c:225
msgid "Supplementary groups"
msgstr "附属组"

#: login-utils/lslogins.c:226
msgid "supplementary group IDs"
msgstr "附属组 ID"

#: login-utils/lslogins.c:226
msgid "Supplementary group IDs"
msgstr "附属组 ID"

#: login-utils/lslogins.c:227
msgid "home directory"
msgstr "主目录"

#: login-utils/lslogins.c:227
msgid "Home directory"
msgstr "主目录"

#: login-utils/lslogins.c:228
msgid "login shell"
msgstr "登录 shell"

#: login-utils/lslogins.c:228
msgid "Shell"
msgstr "shell"

#: login-utils/lslogins.c:229
msgid "full user name"
msgstr "完整用户名"

#: login-utils/lslogins.c:229
msgid "Gecos field"
msgstr "Gecos 字段"

#: login-utils/lslogins.c:230
msgid "date of last login"
msgstr "上次登录日期"

#: login-utils/lslogins.c:230
msgid "Last login"
msgstr "上次登录"

#: login-utils/lslogins.c:231
msgid "last tty used"
msgstr "上次使用的终端"

#: login-utils/lslogins.c:231
msgid "Last terminal"
msgstr "上次的终端"

#: login-utils/lslogins.c:232
msgid "hostname during the last session"
msgstr "上次会话时的主机名(hostname)"

#: login-utils/lslogins.c:232
msgid "Last hostname"
msgstr "上次的主机名"

#: login-utils/lslogins.c:233
msgid "date of last failed login"
msgstr "上次登录失败的日期"

#: login-utils/lslogins.c:233
msgid "Failed login"
msgstr "失败的登录"

#: login-utils/lslogins.c:234
msgid "where did the login fail?"
msgstr "登录在哪里失败的？"

#: login-utils/lslogins.c:234
msgid "Failed login terminal"
msgstr "登录终端失败"

#: login-utils/lslogins.c:235
msgid "user's hush settings"
msgstr "用户的静默(hush)设置"

#: login-utils/lslogins.c:235
msgid "Hushed"
msgstr "已静默"

#: login-utils/lslogins.c:236
msgid "days user is warned of password expiration"
msgstr "警告用户密码过期的天数"

#: login-utils/lslogins.c:236
msgid "Password expiration warn interval"
msgstr "密码过期警告的间隔"

#: login-utils/lslogins.c:237
msgid "password expiration date"
msgstr "密码过期日"

#: login-utils/lslogins.c:237
msgid "Password expiration"
msgstr "密码过期"

#: login-utils/lslogins.c:238
msgid "date of last password change"
msgstr "上次更改密码的日期"

#: login-utils/lslogins.c:238
msgid "Password changed"
msgstr "密码已更改"

#: login-utils/lslogins.c:239
msgid "number of days required between changes"
msgstr "更改密码的限期(天)"

#: login-utils/lslogins.c:239
msgid "Minimum change time"
msgstr "最小更改时间"

#: login-utils/lslogins.c:240
msgid "max number of days a password may remain unchanged"
msgstr "密码可以多久不更改(天数)"

#: login-utils/lslogins.c:240
msgid "Maximum change time"
msgstr "最大更改时间"

#: login-utils/lslogins.c:241
msgid "the user's security context"
msgstr "用户的安全环境(context)"

#: login-utils/lslogins.c:241
msgid "Selinux context"
msgstr "Selinux 环境"

#: login-utils/lslogins.c:242
msgid "number of processes run by the user"
msgstr "用户运行的进程数"

#: login-utils/lslogins.c:242
msgid "Running processes"
msgstr "运行中的进程"

#: login-utils/lslogins.c:288 misc-utils/findmnt.c:136 misc-utils/lsblk.c:241
#: sys-utils/lsipc.c:204 sys-utils/lsmem.c:147
#, c-format
msgid "too many columns specified, the limit is %zu columns"
msgstr "指定了过多的列，限制是 %zu 列"

#: login-utils/lslogins.c:342 sys-utils/lsipc.c:457
msgid "unsupported time type"
msgstr "不支持的时间类型"

#: login-utils/lslogins.c:346
msgid "failed to compose time string"
msgstr "生成时间字符串失败"

#: login-utils/lslogins.c:643
msgid "failed to get supplementary groups"
msgstr "获得附属组失败"

#: login-utils/lslogins.c:1068
msgid "internal error: unknown column"
msgstr "内部错误：未知的列"

#: login-utils/lslogins.c:1166
#, c-format
msgid ""
"\n"
"Last logs:\n"
msgstr ""
"\n"
"上次的日志：\n"

#: login-utils/lslogins.c:1226 login-utils/nologin.c:27
#: misc-utils/lslocks.c:495 misc-utils/mcookie.c:83 misc-utils/uuidd.c:62
#: misc-utils/uuidgen.c:26 sys-utils/dmesg.c:266 sys-utils/ipcmk.c:67
#: sys-utils/lscpu.c:1900 sys-utils/lsipc.c:278 sys-utils/lsmem.c:496
#: sys-utils/readprofile.c:104 sys-utils/rtcwake.c:98 term-utils/setterm.c:379
#: text-utils/line.c:31
#, c-format
msgid " %s [options]\n"
msgstr " %s [选项]\n"

#: login-utils/lslogins.c:1229
msgid "Display information about known users in the system.\n"
msgstr "显示系统中已知用户的信息。\n"

#: login-utils/lslogins.c:1232
msgid " -a, --acc-expiration     display info about passwords expiration\n"
msgstr " -a, --acc-expiration     显示关于密码过期的信息\n"

#: login-utils/lslogins.c:1233
msgid " -c, --colon-separate     display data in a format similar to /etc/passwd\n"
msgstr " -c, --colon-separate     以与 /etc/passwd 相似的格式显示日期\n"

#: login-utils/lslogins.c:1234 sys-utils/lsipc.c:297
msgid " -e, --export             display in an export-able output format\n"
msgstr " -e, --export             以可导出的格式显示\n"

#: login-utils/lslogins.c:1235
msgid " -f, --failed             display data about the users' last failed logins\n"
msgstr " -f, --failed             显示有关该用户上次登录失败的数据\n"

#: login-utils/lslogins.c:1236
msgid " -G, --supp-groups        display information about groups\n"
msgstr " -G, --supp-groups        显示与组相关的信息\n"

#: login-utils/lslogins.c:1237
msgid " -g, --groups=<groups>    display users belonging to a group in <groups>\n"
msgstr " -g, --groups=<groups>    显示属于<groups>中的组的用户\n"

#: login-utils/lslogins.c:1238
msgid " -L, --last               show info about the users' last login sessions\n"
msgstr " -L, --last               显示关于该用户上次登录会话的信息\n"

#: login-utils/lslogins.c:1239
msgid " -l, --logins=<logins>    display only users from <logins>\n"
msgstr " -l, --logins=<登录方式>  只显示以指定<登录方式>登录的用户\n"

#: login-utils/lslogins.c:1240 sys-utils/lsipc.c:299
msgid " -n, --newline            display each piece of information on a new line\n"
msgstr " -n, --newline            逐行显示每一部分信息\n"

#: login-utils/lslogins.c:1241 sys-utils/lsipc.c:292
msgid "     --noheadings         don't print headings\n"
msgstr "      --noheadings     不打印标题\n"

#: login-utils/lslogins.c:1242 sys-utils/lsipc.c:293
msgid "     --notruncate         don't truncate output\n"
msgstr "     --notruncate         不截断输出\n"

#: login-utils/lslogins.c:1243 sys-utils/lsipc.c:301
msgid " -o, --output[=<list>]    define the columns to output\n"
msgstr " -o, --output[=<列表>]    定义要输出的列\n"

#: login-utils/lslogins.c:1244
msgid " -p, --pwd                display information related to login by password.\n"
msgstr " -p, --pwd                显示与 用密码登录 相关的信息。\n"

#: login-utils/lslogins.c:1245 sys-utils/lsipc.c:303
msgid " -r, --raw                display in raw mode\n"
msgstr " -r, --raw                以原始方式显示\n"

#: login-utils/lslogins.c:1246
msgid " -s, --system-accs        display system accounts\n"
msgstr " -s, --system-accs        显示系统帐户\n"

#: login-utils/lslogins.c:1247 sys-utils/lsipc.c:294
msgid "     --time-format=<type> display dates in short, full or iso format\n"
msgstr "     --time-format=<格式>  以短、长或 iso 格式显示日期\n"

#: login-utils/lslogins.c:1248
msgid " -u, --user-accs          display user accounts\n"
msgstr " -u, --user-accs          显示用户帐户\n"

#: login-utils/lslogins.c:1249
msgid " -Z, --context            display SELinux contexts\n"
msgstr " -Z, --context            显示 SELinux 环境\n"

#: login-utils/lslogins.c:1250
msgid " -z, --print0             delimit user entries with a nul character\n"
msgstr " -z, --print0             用空字符(nul)分隔用户记录项\n"

#: login-utils/lslogins.c:1251
msgid "     --wtmp-file <path>   set an alternate path for wtmp\n"
msgstr "     --wtmp-file <路径>   设置 wtmp 的可选路径\n"

#: login-utils/lslogins.c:1252
msgid "     --btmp-file <path>   set an alternate path for btmp\n"
msgstr "     --btmp-file <路径>   设置 btmp 的可选路径\n"

#: login-utils/lslogins.c:1434
msgid "failed to request selinux state"
msgstr "请求 selinux 状态失败"

#: login-utils/lslogins.c:1448 login-utils/lslogins.c:1452
msgid "Only one user may be specified. Use -l for multiple users."
msgstr "只能指定一个用户。多用户请使用 -l。"

#: login-utils/newgrp.c:49 login-utils/newgrp.c:55
msgid "could not set terminal attributes"
msgstr "无法设置终端属性"

#: login-utils/newgrp.c:57
msgid "getline() failed"
msgstr "getline() 失败"

#: login-utils/newgrp.c:150
msgid "Password: "
msgstr "密码："

#: login-utils/newgrp.c:160 login-utils/sulogin.c:995
msgid "crypt failed"
msgstr "crypt 失败"

#: login-utils/newgrp.c:173
#, c-format
msgid " %s <group>\n"
msgstr " %s <组>\n"

#: login-utils/newgrp.c:176
msgid "Log in to a new group.\n"
msgstr "以新的组登录。\n"

#: login-utils/newgrp.c:213
msgid "who are you?"
msgstr "您是哪位？"

#: login-utils/newgrp.c:217 login-utils/newgrp.c:229 sys-utils/nsenter.c:474
msgid "setgid failed"
msgstr "setgid 失败"

#: login-utils/newgrp.c:222 login-utils/newgrp.c:224
msgid "no such group"
msgstr "无此组"

#: login-utils/newgrp.c:233 sys-utils/nsenter.c:476
msgid "setuid failed"
msgstr "setuid 失败"

#: login-utils/nologin.c:30
msgid "Politely refuse a login.\n"
msgstr "客气的拒绝登录。\n"

#: login-utils/nologin.c:87
#, c-format
msgid "This account is currently not available.\n"
msgstr "此帐户目前不可用。\n"

#: login-utils/su-common.c:224
msgid " (core dumped)"
msgstr " (核心已转储)"

#: login-utils/su-common.c:278 term-utils/script.c:632
msgid "failed to get terminal attributes"
msgstr "取终端属性失败"

#: login-utils/su-common.c:302
#, fuzzy
msgid "failed to create pseudo-terminal"
msgstr "分配输出表失败"

#: login-utils/su-common.c:488 login-utils/su-common.c:762
msgid "cannot block signals"
msgstr "无法阻塞信号"

#: login-utils/su-common.c:524 misc-utils/uuidd.c:411 term-utils/script.c:494
msgid "poll failed"
msgstr "轮询失败"

#: login-utils/su-common.c:670
#, fuzzy
msgid "failed to modify environment"
msgstr "打开目录失败"

#: login-utils/su-common.c:706
msgid "may not be used by non-root users"
msgstr "非 root 用户不能使用"

#: login-utils/su-common.c:730
msgid "incorrect password"
msgstr "密码错误"

#: login-utils/su-common.c:743
#, c-format
msgid "cannot open session: %s"
msgstr "无法打开会话：%s"

#: login-utils/su-common.c:779
msgid "cannot initialize signal mask for session"
msgstr ""

#: login-utils/su-common.c:787
#, fuzzy
msgid "cannot initialize signal mask"
msgstr "无法阻塞信号"

#: login-utils/su-common.c:797
#, fuzzy
msgid "cannot set signal handler for session"
msgstr "无法设置信号处理函数"

#: login-utils/su-common.c:805 misc-utils/uuidd.c:398 sys-utils/lscpu.c:743
#: term-utils/script.c:796
msgid "cannot set signal handler"
msgstr "无法设置信号处理函数"

#: login-utils/su-common.c:813
#, fuzzy
msgid "cannot set signal mask"
msgstr "无法设置信号处理函数"

#: login-utils/su-common.c:841
msgid "cannot create child process"
msgstr "无法创建子进程"

#: login-utils/su-common.c:860
#, c-format
msgid "cannot change directory to %s"
msgstr "无法更改到 %s 目录"

#: login-utils/su-common.c:879
#, c-format
msgid ""
"\n"
"Session terminated, killing shell..."
msgstr ""
"\n"
"会话已终止，正在杀死 shell..."

#: login-utils/su-common.c:890
#, c-format
msgid " ...killed.\n"
msgstr " ...已杀死。\n"

#: login-utils/su-common.c:941
#, fuzzy
msgid "failed to set the PATH environment variable"
msgstr "设置环境变量 %s 失败"

#: login-utils/su-common.c:1006
msgid "cannot set groups"
msgstr "无法设置 组"

#: login-utils/su-common.c:1012
#, fuzzy, c-format
msgid "failed to user credentials: %s"
msgstr "解析级别“%s”失败"

#: login-utils/su-common.c:1022 sys-utils/eject.c:660
msgid "cannot set group id"
msgstr "无法设置 组 id"

#: login-utils/su-common.c:1024 sys-utils/eject.c:663
msgid "cannot set user id"
msgstr "无法设置 用户 id"

#: login-utils/su-common.c:1092
msgid " -m, -p, --preserve-environment  do not reset environment variables\n"
msgstr " -m, -p, --preserve-environment  不重置环境变量\n"

#: login-utils/su-common.c:1093
msgid " -g, --group <group>             specify the primary group\n"
msgstr " -g, --group <组>                指定主组\n"

#: login-utils/su-common.c:1094
#, fuzzy
msgid " -G, --supp-group <group>        specify a supplemental group\n"
msgstr ""
" -G, --supp-group <组>        指定一个辅助组\n"
"\n"

#: login-utils/su-common.c:1097
msgid " -, -l, --login                  make the shell a login shell\n"
msgstr " -, -l, --login                  使 shell 成为登录 shell\n"

#: login-utils/su-common.c:1098
msgid " -c, --command <command>         pass a single command to the shell with -c\n"
msgstr " -c, --command <命令>            使用 -c 向 shell 传递一条命令\n"

#: login-utils/su-common.c:1099
msgid ""
" --session-command <command>     pass a single command to the shell with -c\n"
"                                   and do not create a new session\n"
msgstr ""
" --session-command <命令>        使用 -c 向 shell 传递一条命令\n"
"                                   而不创建新会话\n"

#: login-utils/su-common.c:1101
msgid " -f, --fast                      pass -f to the shell (for csh or tcsh)\n"
msgstr " -f, --fast                      向shell 传递 -f 选项(csh 或 tcsh)\n"

#: login-utils/su-common.c:1102
msgid " -s, --shell <shell>             run <shell> if /etc/shells allows it\n"
msgstr " -s, --shell <shell>             若 /etc/shells 允许，运行<shell>\n"

#: login-utils/su-common.c:1103
#, fuzzy
msgid " -P, --pty                       create a new pseudo-terminal\n"
msgstr " -t, --table              创建表格\n"

#: login-utils/su-common.c:1113
#, fuzzy, c-format
msgid ""
" %1$s [options] -u <user> [[--] <command>]\n"
" %1$s [options] [-] [<user> [<argument>...]]\n"
msgstr ""
" %1$s [选项] <设备> [[-N] <分区>]\n"
" %1$s [选项] <命令>\n"

#: login-utils/su-common.c:1118
#, fuzzy
msgid ""
"Run <command> with the effective user ID and group ID of <user>.  If -u is\n"
"not given, fall back to su(1)-compatible semantics and execute standard shell.\n"
"The options -c, -f, -l, and -s are mutually exclusive with -u.\n"
msgstr ""
"\n"
"以<用户>的有效用户 id 和组 id 运行<命令>。如果未给出 -u，\n"
"将退而使用与 su(1) 兼容的语法并执行标准 shell。\n"
"选项 -c、-f、-l 及 -s 与 -u 相互排斥。\n"

#: login-utils/su-common.c:1123
#, fuzzy
msgid " -u, --user <user>               username\n"
msgstr " -u, --user <用户>             用户名\n"

#: login-utils/su-common.c:1134
#, c-format
msgid " %s [options] [-] [<user> [<argument>...]]\n"
msgstr " %s [选项] [-] [<用户> [<参数>...]]\n"

#: login-utils/su-common.c:1138
#, fuzzy
msgid ""
"Change the effective user ID and group ID to that of <user>.\n"
"A mere - implies -l.  If <user> is not given, root is assumed.\n"
msgstr ""
"\n"
"将有效用户 id 和组 id 更改为<用户>的 id。\n"
"单个 - 视为 -l。如果未指定<用户>，将假定为 root。\n"

#: login-utils/su-common.c:1184
#, c-format
msgid "specifying more than %d supplemental group is not possible"
msgid_plural "specifying more than %d supplemental groups is not possible"
msgstr[0] "不能指定多于 %d 个补充组"

#: login-utils/su-common.c:1190
#, c-format
msgid "group %s does not exist"
msgstr "组 %s 不存在"

#: login-utils/su-common.c:1290
#, fuzzy
msgid "--pty is not supported for your system"
msgstr "您的系统不支持 --reload"

#: login-utils/su-common.c:1326
msgid "ignoring --preserve-environment, it's mutually exclusive with --login"
msgstr "将忽略 --preserve-environment，它与 --login 互斥。"

#: login-utils/su-common.c:1340
msgid "options --{shell,fast,command,session-command,login} and --user are mutually exclusive"
msgstr "选项 --{shell,fast,command,session-command,login} 和 --user 互斥"

#: login-utils/su-common.c:1343
msgid "no command was specified"
msgstr "没有指定命令"

#: login-utils/su-common.c:1355
msgid "only root can specify alternative groups"
msgstr "只有 root 用户能指定替代组"

#: login-utils/su-common.c:1365
#, c-format
msgid "user %s does not exist"
msgstr "用户 %s 不存在"

#: login-utils/su-common.c:1398
#, c-format
msgid "using restricted shell %s"
msgstr "将使用受限 shell %s"

#: login-utils/su-common.c:1429
#, c-format
msgid "warning: cannot change directory to %s"
msgstr "警告：无法更改到 %s 目录"

#: login-utils/sulogin.c:130
msgid "tcgetattr failed"
msgstr "tcgetattr 失败"

#: login-utils/sulogin.c:207
msgid "tcsetattr failed"
msgstr "tcsetattr 失败"

#: login-utils/sulogin.c:469
#, c-format
msgid "%s: no entry for root\n"
msgstr "%s：无 root 的记录\n"

#: login-utils/sulogin.c:496
#, c-format
msgid "%s: no entry for root"
msgstr "%s：无 root 的记录"

#: login-utils/sulogin.c:501
#, c-format
msgid "%s: root password garbled"
msgstr "%s：root 密码有误"

#: login-utils/sulogin.c:529
#, c-format
msgid ""
"\n"
"Cannot open access to console, the root account is locked.\n"
"See sulogin(8) man page for more details.\n"
"\n"
"Press Enter to continue.\n"
msgstr ""
"\n"
"无法访问终端，root 账号被锁。 \n"
"参阅 sulogin(8) 帮助页面了解更多信息。\n"
"\n"
"按 Enter 继续。\n"

#: login-utils/sulogin.c:535
#, c-format
msgid "Give root password for login: "
msgstr "指定 root 的登录密码："

#: login-utils/sulogin.c:537
#, c-format
msgid "Press Enter for login: "
msgstr "按 Enter 键登录："

#: login-utils/sulogin.c:540
#, c-format
msgid "Give root password for maintenance\n"
msgstr "指定 root 的维护密码\n"

#: login-utils/sulogin.c:542
#, c-format
msgid "Press Enter for maintenance\n"
msgstr "按 Enter 键进行维护\n"

#: login-utils/sulogin.c:543
#, c-format
msgid "(or press Control-D to continue): "
msgstr "(或按 Control-D 键继续)："

#: login-utils/sulogin.c:733
msgid "change directory to system root failed"
msgstr "更改到系统根目录失败"

#: login-utils/sulogin.c:782
msgid "setexeccon failed"
msgstr "setexeccon 失败"

#: login-utils/sulogin.c:803
#, c-format
msgid " %s [options] [tty device]\n"
msgstr " %s [选项] [tty 设备]\n"

#: login-utils/sulogin.c:806
msgid "Single-user login.\n"
msgstr "单用户登录。\n"

#: login-utils/sulogin.c:809
msgid ""
" -p, --login-shell        start a login shell\n"
" -t, --timeout <seconds>  max time to wait for a password (default: no limit)\n"
" -e, --force              examine password files directly if getpwnam(3) fails\n"
msgstr ""
" -p, --login-shell        启动登录 shell\n"
" -t, --timeout <秒数>     等待密码的最大时间(默认：无限制)\n"
" -e, --force              如果 getpwnam(3) 失败，直接检查密码文件\n"

#: login-utils/sulogin.c:863 misc-utils/findmnt.c:1468 sys-utils/wdctl.c:524
#: term-utils/agetty.c:817 term-utils/wall.c:216
msgid "invalid timeout argument"
msgstr "无效的 timeout 超时参数"

#: login-utils/sulogin.c:884
msgid "only superuser can run this program"
msgstr "只有超级用户能运行此程序"

#: login-utils/sulogin.c:927
msgid "cannot open console"
msgstr "打不开终端"

#: login-utils/sulogin.c:934
msgid "cannot open password database"
msgstr "无法打开密码数据库"

#: login-utils/sulogin.c:1010
#, fuzzy, c-format
msgid ""
"cannot execute su shell\n"
"\n"
msgstr ""
"无法执行 su shell\n"
"\n"

#: login-utils/sulogin.c:1017
msgid ""
"Timed out\n"
"\n"
msgstr ""
"超时\n"
"\n"

#: login-utils/sulogin.c:1049
#, fuzzy
msgid ""
"cannot wait on su shell\n"
"\n"
msgstr ""
"无法等待 su shell\n"
"\n"

#: login-utils/utmpdump.c:174
#, c-format
msgid "%s: cannot add inotify watch."
msgstr "%s：无法添加 inotify 观察。"

#: login-utils/utmpdump.c:183
#, c-format
msgid "%s: cannot read inotify events"
msgstr "%s：无法读 inotify 事件"

#: login-utils/utmpdump.c:244 login-utils/utmpdump.c:249
msgid "Extraneous newline in file. Exiting."
msgstr "文件中有无关的换行符。将退出。"

#: login-utils/utmpdump.c:303
#, c-format
msgid " %s [options] [filename]\n"
msgstr " %s [选项] [文件名]\n"

#: login-utils/utmpdump.c:306
msgid "Dump UTMP and WTMP files in raw format.\n"
msgstr "以原始格式转储 UTMP 和 WTMP 文件。\n"

#: login-utils/utmpdump.c:309
msgid " -f, --follow         output appended data as the file grows\n"
msgstr " -f, --follow         随文件增长输出追加的数据\n"

#: login-utils/utmpdump.c:310
msgid " -r, --reverse        write back dumped data into utmp file\n"
msgstr " -r, --reverse        将转储的数据写回 utmp 文件\n"

#: login-utils/utmpdump.c:311
msgid " -o, --output <file>  write to file instead of standard output\n"
msgstr " -o, --output <文件>  写入文件而非标准输出\n"

#: login-utils/utmpdump.c:377
msgid "following standard input is unsupported"
msgstr "不支持跟随(follow)标准输入"

#: login-utils/utmpdump.c:383
#, c-format
msgid "Utmp undump of %s\n"
msgstr "%s 的 Utmp undump\n"

#: login-utils/utmpdump.c:386
#, c-format
msgid "Utmp dump of %s\n"
msgstr "%s 的 Utmp dump\n"

#: login-utils/vipw.c:145
msgid "can't open temporary file"
msgstr "无法打开临时文件"

#: login-utils/vipw.c:161
#, c-format
msgid "%s: create a link to %s failed"
msgstr "%s：创建指向 %s 的链接失败"

#: login-utils/vipw.c:168
#, c-format
msgid "Can't get context for %s"
msgstr "无法获取 %s 的环境"

#: login-utils/vipw.c:174
#, c-format
msgid "Can't set context for %s"
msgstr "无法设置 %s 的环境"

#: login-utils/vipw.c:239
#, c-format
msgid "%s unchanged"
msgstr "%s 未改变"

#: login-utils/vipw.c:257
msgid "cannot get lock"
msgstr "无法获得锁"

#: login-utils/vipw.c:284
msgid "no changes made"
msgstr "无改变"

#: login-utils/vipw.c:293
msgid "cannot chmod file"
msgstr "无法对文件 chmod"

#: login-utils/vipw.c:308
msgid "Edit the password or group file.\n"
msgstr "编辑密码或组文件。\n"

#: login-utils/vipw.c:361
msgid "You are using shadow groups on this system.\n"
msgstr "您正在使用此系统上的遮蔽(shadow)组。\n"

#: login-utils/vipw.c:362
msgid "You are using shadow passwords on this system.\n"
msgstr "您正在使用此系统上的遮蔽(shadow)密码。\n"

#. TRANSLATORS: this program uses for y and n rpmatch(3),
#. * which means they can be translated.
#: login-utils/vipw.c:366
#, c-format
msgid "Would you like to edit %s now [y/n]? "
msgstr "您想现在编辑 %s 吗[y/n]？"

#: misc-utils/blkid.c:66
#, fuzzy, c-format
msgid "%s from %s  (libblkid %s, %s)\n"
msgstr "%s，来自 %s(libmount %s"

#: misc-utils/blkid.c:76
#, c-format
msgid ""
" %s --label <label> | --uuid <uuid>\n"
"\n"
msgstr ""

#: misc-utils/blkid.c:77
#, c-format
msgid ""
" %s [--cache-file <file>] [-ghlLv] [--output <format>] [--match-tag <tag>] \n"
"       [--match-token <token>] [<dev> ...]\n"
"\n"
msgstr ""

#: misc-utils/blkid.c:79
#, c-format
msgid ""
" %s -p [--match-tag <tag>] [--offset <offset>] [--size <size>] \n"
"       [--output <format>] <dev> ...\n"
"\n"
msgstr ""

#: misc-utils/blkid.c:81
#, c-format
msgid " %s -i [--match-tag <tag>] [--output <format>] <dev> ...\n"
msgstr ""

#: misc-utils/blkid.c:83
#, fuzzy
msgid ""
" -c, --cache-file <file>    read from <file> instead of reading from the default\n"
"                              cache file (-c /dev/null means no cache)\n"
msgstr ""
" -A, --adjfile <文件>     指定 adjust 文件的路径\n"
"                            默认为 %s\n"

#: misc-utils/blkid.c:85
#, fuzzy
msgid " -d, --no-encoding          don't encode non-printing characters\n"
msgstr " -n, --noheadings          不打印标题\n"

#: misc-utils/blkid.c:86
msgid " -g, --garbage-collect      garbage collect the blkid cache\n"
msgstr ""

#: misc-utils/blkid.c:87
msgid ""
" -o, --output <format>      output format; can be one of:\n"
"                              value, device, export or full; (default: full)\n"
msgstr ""

#: misc-utils/blkid.c:89
#, fuzzy
msgid " -k, --list-filesystems     list all known filesystems/RAIDs and exit\n"
msgstr " -l, --list-shells    打印 shell 列表并退出\n"

#: misc-utils/blkid.c:90
msgid " -s, --match-tag <tag>      show specified tag(s) (default show all tags)\n"
msgstr ""

#: misc-utils/blkid.c:91
msgid " -t, --match-token <token>  find device with a specific token (NAME=value pair)\n"
msgstr ""

#: misc-utils/blkid.c:92
#, fuzzy
msgid " -l, --list-one             look up only first device with token specified by -t\n"
msgstr " -l, --list                    列出所有或指定的信息(默认)\n"

#: misc-utils/blkid.c:93
#, fuzzy
msgid " -L, --label <label>        convert LABEL to device name\n"
msgstr " -s, --size <尺寸>         设备尺寸\n"

#: misc-utils/blkid.c:94
#, fuzzy
msgid " -U, --uuid <uuid>          convert UUID to device name\n"
msgstr " -u, --user <用户>             用户名\n"

#: misc-utils/blkid.c:95
#, fuzzy
msgid " <dev>                      specify device(s) to probe (default: all devices)\n"
msgstr " <设备>                    设备(通常是磁盘)的路径\n"

#: misc-utils/blkid.c:97
#, fuzzy
msgid "Low-level probing options:\n"
msgstr "调度选项：\n"

#: misc-utils/blkid.c:98
#, fuzzy
msgid " -p, --probe                low-level superblocks probing (bypass cache)\n"
msgstr " -p, --pid                 取消共享 pid 名字空间\n"

#: misc-utils/blkid.c:99
#, fuzzy
msgid " -i, --info                 gather information about I/O limits\n"
msgstr " -i, --info                只打印有关采样步骤(sampling step)的信息\n"

#: misc-utils/blkid.c:100
#, fuzzy
msgid " -S, --size <size>          overwrite device size\n"
msgstr " -s, --size <尺寸>         设备尺寸\n"

#: misc-utils/blkid.c:101
#, fuzzy
msgid " -O, --offset <offset>      probe at the given offset\n"
msgstr " -H, --host <主机名>        指定登录主机\n"

#: misc-utils/blkid.c:102
#, fuzzy
msgid " -u, --usages <list>        filter by \"usage\" (e.g. -u filesystem,raid)\n"
msgstr " -t, --types <列表>      限制文件系统集合\n"

#: misc-utils/blkid.c:103
#, fuzzy
msgid " -n, --match-types <list>   filter by filesystem type (e.g. -n vfat,ext3)\n"
msgstr " -t, --types <列表>      限制文件系统集合\n"

#: misc-utils/blkid.c:235
msgid "(mounted, mtpt unknown)"
msgstr ""

#: misc-utils/blkid.c:237
#, fuzzy
msgid "(in use)"
msgstr "标记为已使用"

#: misc-utils/blkid.c:239
#, fuzzy
msgid "(not mounted)"
msgstr "%s：未挂载"

#: misc-utils/blkid.c:503
#, fuzzy, c-format
msgid "error: %s"
msgstr "解析错误：%s"

#: misc-utils/blkid.c:548
#, c-format
msgid "%s: ambivalent result (probably more filesystems on the device, use wipefs(8) to see more details)"
msgstr ""

#: misc-utils/blkid.c:594
#, fuzzy, c-format
msgid "unknown keyword in -u <list> argument: '%s'"
msgstr "未知参数：%s"

#: misc-utils/blkid.c:611
msgid "error: -u <list> argument is empty"
msgstr ""

#: misc-utils/blkid.c:756
#, fuzzy, c-format
msgid "unsupported output format %s"
msgstr "不支持的参数格式：%s"

#: misc-utils/blkid.c:759 misc-utils/wipefs.c:697
msgid "invalid offset argument"
msgstr "无效的 偏移 参数"

#: misc-utils/blkid.c:766
#, fuzzy
msgid "Too many tags specified"
msgstr "没有指定命令"

#: misc-utils/blkid.c:772
#, fuzzy
msgid "invalid size argument"
msgstr "无效的 时间 参数"

#: misc-utils/blkid.c:776
msgid "Can only search for one NAME=value pair"
msgstr ""

#: misc-utils/blkid.c:783
msgid "-t needs NAME=value pair"
msgstr ""

#: misc-utils/blkid.c:833
msgid "The low-level probing mode does not support 'list' output format"
msgstr ""

#: misc-utils/blkid.c:846
msgid "The low-level probing mode requires a device"
msgstr ""

#: misc-utils/blkid.c:896
msgid "The lookup option requires a search type specified using -t"
msgstr ""

#: misc-utils/cal.c:411
msgid "invalid month argument"
msgstr "无效的月份参数"

#: misc-utils/cal.c:419
msgid "invalid week argument"
msgstr "无效的 周 参数"

#: misc-utils/cal.c:421
msgid "illegal week value: use 1-54"
msgstr "非法的 周 值：请使用 1-54"

#: misc-utils/cal.c:466
#, c-format
msgid "failed to parse timestamp or unknown month name: %s"
msgstr " 解析时间戳失败或月份名未知：%s"

#: misc-utils/cal.c:475
msgid "illegal day value"
msgstr "日 值不合法"

#: misc-utils/cal.c:477 misc-utils/cal.c:501
#, c-format
msgid "illegal day value: use 1-%d"
msgstr "日 值不合法：请使用 1-%d"

#: misc-utils/cal.c:481 misc-utils/cal.c:489
msgid "illegal month value: use 1-12"
msgstr "月份值不合法：请使用 1-12"

#: misc-utils/cal.c:485
#, c-format
msgid "unknown month name: %s"
msgstr "月份名未知：%s"

#: misc-utils/cal.c:492 misc-utils/cal.c:496
msgid "illegal year value"
msgstr "年份值不合法"

#: misc-utils/cal.c:494
msgid "illegal year value: use positive integer"
msgstr "年份值不合法：请使用正整数"

#: misc-utils/cal.c:530 misc-utils/cal.c:543
#, c-format
msgid "illegal week value: year %d doesn't have week %d"
msgstr "非法的 周 值：%d 年没有第 %d 周"

#: misc-utils/cal.c:742
#, c-format
msgid "%s"
msgstr "%s"

#: misc-utils/cal.c:748
#, c-format
msgid "%04d"
msgstr "%04d"

#: misc-utils/cal.c:754
#, c-format
msgid "%s %04d"
msgstr "%s %04d"

#: misc-utils/cal.c:1094
#, c-format
msgid " %s [options] [[[day] month] year]\n"
msgstr " %s [选项] [[[日] 月] 年]\n"

#: misc-utils/cal.c:1095
#, c-format
msgid " %s [options] <timestamp|monthname>\n"
msgstr " %s [选项] <时间戳|月份名>\n"

#: misc-utils/cal.c:1098
msgid "Display a calendar, or some part of it.\n"
msgstr "显示日历或部分日历。\n"

#: misc-utils/cal.c:1099
msgid "Without any arguments, display the current month.\n"
msgstr "不带参数时，显示当月日历。\n"

#: misc-utils/cal.c:1102
msgid " -1, --one             show only a single month (default)\n"
msgstr " -1, --one             只显示一个月(默认)\n"

#: misc-utils/cal.c:1103
msgid " -3, --three           show three months spanning the date\n"
msgstr " -3, --three           显示该日期前后三个月\n"

#: misc-utils/cal.c:1104
msgid " -n, --months <num>    show num months starting with date's month\n"
msgstr " -n, --months < 数字>   显示以日期所在月份开始的若干个月\n"

#: misc-utils/cal.c:1105
msgid " -S, --span            span the date when displaying multiple months\n"
msgstr " -S, --span            显示多个月份时的日期范围\n"

#: misc-utils/cal.c:1106
msgid " -s, --sunday          Sunday as first day of week\n"
msgstr " -s, --sunday          周日作为一周的第一天\n"

#: misc-utils/cal.c:1107
msgid " -m, --monday          Monday as first day of week\n"
msgstr " -m, --monday          周一作为一周的第一天\n"

#: misc-utils/cal.c:1108
#, fuzzy
msgid " -j, --julian          use day-of-year for all calendars\n"
msgstr " -j, --julian          输出儒略日期\n"

#: misc-utils/cal.c:1109
msgid "     --reform <val>    Gregorian reform date (1752|gregorian|iso|julian)\n"
msgstr ""

#: misc-utils/cal.c:1110
#, fuzzy
msgid "     --iso             alias for --reform=iso\n"
msgstr "                t - 原生格式的表"

#: misc-utils/cal.c:1111
msgid " -y, --year            show the whole year\n"
msgstr " -y, --year            显示全年\n"

#: misc-utils/cal.c:1112
msgid " -Y, --twelve          show the next twelve months\n"
msgstr " -Y, --twelve          显示之后的 12 个月\n"

#: misc-utils/cal.c:1113
msgid " -w, --week[=<num>]    show US or ISO-8601 week numbers\n"
msgstr " -w, --week[=<数字>]   显示美国或 ISO-8601 周数\n"

#: misc-utils/cal.c:1114
msgid "     --color[=<when>]  colorize messages (auto, always or never)\n"
msgstr "     --color[=<时机>]  消息彩色显示(auto, always 或 never)\n"

#: misc-utils/fincore.c:61
#, fuzzy
msgid "file data resident in memory in pages"
msgstr "共享内存页"

#: misc-utils/fincore.c:62
#, fuzzy
msgid "file data resident in memory in bytes"
msgstr "共享内存页"

#: misc-utils/fincore.c:63
#, fuzzy
msgid "size of the file"
msgstr "磁盘容量"

#: misc-utils/fincore.c:64
#, fuzzy
msgid "file name"
msgstr "文件名"

#: misc-utils/fincore.c:174
#, fuzzy, c-format
msgid "failed to do mincore: %s"
msgstr "读符号链接失败：%s"

#: misc-utils/fincore.c:212
#, fuzzy, c-format
msgid "failed to do mmap: %s"
msgstr "读取失败︰ %s"

#: misc-utils/fincore.c:240
#, fuzzy, c-format
msgid "failed to open: %s"
msgstr "解析 %s 失败"

#: misc-utils/fincore.c:245
#, fuzzy, c-format
msgid "failed to do fstat: %s"
msgstr "读取失败︰ %s"

#: misc-utils/fincore.c:266
#, c-format
msgid " %s [options] file...\n"
msgstr " %s [选项] 文件...\n"

#: misc-utils/fincore.c:269
#, fuzzy
msgid " -J, --json            use JSON output format\n"
msgstr " -J, --json              使用 JSON 输出格式\n"

#: misc-utils/fincore.c:270
#, fuzzy
msgid " -b, --bytes           print sizes in bytes rather than in human readable format\n"
msgstr " -b, --bytes           以字节为单位而非易读的格式来打印大小\n"

#: misc-utils/fincore.c:271
#, fuzzy
msgid " -n, --noheadings      don't print headings\n"
msgstr " -n, --noheadings       不打印标题\n"

#: misc-utils/fincore.c:272
#, fuzzy
msgid " -o, --output <list>   output columns\n"
msgstr " -o, --output <列表>  输出列\n"

#: misc-utils/fincore.c:273
#, fuzzy
msgid " -r, --raw             use raw output format\n"
msgstr " -r, --raw              使用原生输出格式\n"

#: misc-utils/fincore.c:343 sys-utils/losetup.c:793
msgid "no file specified"
msgstr "未指定文件"

#: misc-utils/findfs.c:28
#, c-format
msgid " %s [options] {LABEL,UUID,PARTUUID,PARTLABEL}=<value>\n"
msgstr " %s [选项] {LABEL,UUID,PARTUUID,PARTLABEL}=<值>\n"

#: misc-utils/findfs.c:32
msgid "Find a filesystem by label or UUID.\n"
msgstr "按标签或 UUID 查找文件系统。\n"

#: misc-utils/findfs.c:75
#, c-format
msgid "unable to resolve '%s'"
msgstr "不能解析“%s”"

#: misc-utils/findmnt.c:99
msgid "source device"
msgstr "源设备"

#: misc-utils/findmnt.c:100
msgid "mountpoint"
msgstr "挂载点"

#: misc-utils/findmnt.c:101 misc-utils/lsblk.c:166
msgid "filesystem type"
msgstr "文件系统类型"

#: misc-utils/findmnt.c:102
msgid "all mount options"
msgstr "全部挂臷选项"

#: misc-utils/findmnt.c:103
msgid "VFS specific mount options"
msgstr "VFS 的特定挂载选项"

#: misc-utils/findmnt.c:104
msgid "FS specific mount options"
msgstr "FS 的特定挂载选项"

#: misc-utils/findmnt.c:105
msgid "filesystem label"
msgstr "文件系统标签"

#: misc-utils/findmnt.c:106 misc-utils/lsblk.c:169
msgid "filesystem UUID"
msgstr "文件系统 UUID"

#: misc-utils/findmnt.c:107
msgid "partition label"
msgstr "分区标签"

#: misc-utils/findmnt.c:109 misc-utils/lsblk.c:165
msgid "major:minor device number"
msgstr "主:次 设备号"

#: misc-utils/findmnt.c:110
msgid "action detected by --poll"
msgstr "--poll 检测到的操作"

#: misc-utils/findmnt.c:111
msgid "old mount options saved by --poll"
msgstr "--poll 保存的旧挂载选项"

#: misc-utils/findmnt.c:112
msgid "old mountpoint saved by --poll"
msgstr "--poll 保存的旧挂载点"

#: misc-utils/findmnt.c:113
msgid "filesystem size"
msgstr "文件系统大小"

#: misc-utils/findmnt.c:114
msgid "filesystem size available"
msgstr "文件系统可用大小"

#: misc-utils/findmnt.c:115
msgid "filesystem size used"
msgstr "文件系统已用大小"

#: misc-utils/findmnt.c:116
msgid "filesystem use percentage"
msgstr "文件系统使用百分比"

#: misc-utils/findmnt.c:117
msgid "filesystem root"
msgstr "文件系统 root"

#: misc-utils/findmnt.c:118
msgid "task ID"
msgstr "任务 ID"

#: misc-utils/findmnt.c:119
msgid "mount ID"
msgstr "挂载 ID"

#: misc-utils/findmnt.c:120
msgid "optional mount fields"
msgstr "可选的挂载字段"

#: misc-utils/findmnt.c:121
msgid "VFS propagation flags"
msgstr "VFS 传播标志"

#: misc-utils/findmnt.c:122
msgid "dump(8) period in days [fstab only]"
msgstr "dump(8) 周期(天数) [仅 fstab]"

#: misc-utils/findmnt.c:123
msgid "pass number on parallel fsck(8) [fstab only]"
msgstr "并行 fsck(8) 的遍数(pass number) [仅 fstab]"

#: misc-utils/findmnt.c:333
#, c-format
msgid "unknown action: %s"
msgstr "未知操作: %s"

#: misc-utils/findmnt.c:643
msgid "mount"
msgstr "挂载"

#: misc-utils/findmnt.c:646
msgid "umount"
msgstr "卸载"

#: misc-utils/findmnt.c:649
msgid "remount"
msgstr "重新挂载"

#: misc-utils/findmnt.c:652
msgid "move"
msgstr "移动"

#: misc-utils/findmnt.c:814 misc-utils/findmnt.c:1077 sys-utils/eject.c:714
#: sys-utils/mount.c:324
msgid "failed to initialize libmount table"
msgstr "初始化 libmount table 失败"

#: misc-utils/findmnt.c:841 text-utils/hexdump-parse.c:84
#, c-format
msgid "can't read %s"
msgstr "不能读 %s"

#: misc-utils/findmnt.c:1017 misc-utils/findmnt.c:1083
#: misc-utils/findmnt-verify.c:94 misc-utils/findmnt-verify.c:481
#: sys-utils/fstrim.c:189 sys-utils/mount.c:133 sys-utils/mount.c:181
#: sys-utils/swapoff.c:55 sys-utils/swapoff.c:154 sys-utils/swapon.c:248
#: sys-utils/swapon.c:278 sys-utils/swapon.c:737 sys-utils/umount.c:174
msgid "failed to initialize libmount iterator"
msgstr "无法初始化 libmount 迭代器"

#: misc-utils/findmnt.c:1089
msgid "failed to initialize libmount tabdiff"
msgstr "初始化 libmount tabdiff 失败"

#: misc-utils/findmnt.c:1117
msgid "poll() failed"
msgstr "poll() 失败"

#: misc-utils/findmnt.c:1192
#, c-format
msgid ""
" %1$s [options]\n"
" %1$s [options] <device> | <mountpoint>\n"
" %1$s [options] <device> <mountpoint>\n"
" %1$s [options] [--source <device>] [--target <path> | --mountpoint <dir>]\n"
msgstr ""
" %1$s [选项]\n"
" %1$s [选项] <设备> | <挂臷点>\n"
" %1$s [选项] <设备> <挂臷点>\n"
" %1$s [选项] [--source <设备>] [--target <挂臷点>]\n"

#: misc-utils/findmnt.c:1199
msgid "Find a (mounted) filesystem.\n"
msgstr "查找(挂载的)文件系统。\n"

#: misc-utils/findmnt.c:1202
msgid " -s, --fstab            search in static table of filesystems\n"
msgstr " -s, --fstab            在文件系统表态表中搜索\n"

#: misc-utils/findmnt.c:1203
#, fuzzy
msgid ""
" -m, --mtab             search in table of mounted filesystems\n"
"                          (includes user space mount options)\n"
msgstr ""
" -k, --kernel           在已挂载文件系统的内核表中搜索\n"
"                          (默认)\n"

#: misc-utils/findmnt.c:1205
msgid ""
" -k, --kernel           search in kernel table of mounted\n"
"                          filesystems (default)\n"
msgstr ""
" -k, --kernel           在已挂载文件系统的内核表中搜索\n"
"                          (默认)\n"

#: misc-utils/findmnt.c:1208
msgid " -p, --poll[=<list>]    monitor changes in table of mounted filesystems\n"
msgstr " -p, --poll[=<列表>]    监测已挂臷文件系统表的改变\n"

#: misc-utils/findmnt.c:1209
msgid " -w, --timeout <num>    upper limit in milliseconds that --poll will block\n"
msgstr " -w, --timeout <数字>   --poll 阻塞的时间上限(毫秒)\n"

#: misc-utils/findmnt.c:1212
msgid " -A, --all              disable all built-in filters, print all filesystems\n"
msgstr " -A, --all              禁用所有内置过滤器，打印所有文件系统\n"

#: misc-utils/findmnt.c:1213
msgid " -a, --ascii            use ASCII chars for tree formatting\n"
msgstr " -a, --ascii            用 ASCII 字符格式化树\n"

#: misc-utils/findmnt.c:1214
msgid " -b, --bytes            print sizes in bytes rather than in human readable format\n"
msgstr " -b, --bytes           以字节为单位而非易读的格式来打印大小\n"

#: misc-utils/findmnt.c:1215
msgid " -C, --nocanonicalize   don't canonicalize when comparing paths\n"
msgstr " -c, --no-canonicalize  在比较路径时不对路径规范化\n"

#: misc-utils/findmnt.c:1216
msgid " -c, --canonicalize     canonicalize printed paths\n"
msgstr " -c, --no-canonicalize  对打印的路径规范化\n"

#: misc-utils/findmnt.c:1217
msgid " -D, --df               imitate the output of df(1)\n"
msgstr " -D, --df               仿照 df(1) 输出\n"

#: misc-utils/findmnt.c:1218
msgid " -d, --direction <word> direction of search, 'forward' or 'backward'\n"
msgstr " -d, --direction <单词> 搜索方向，“forward”(往前)或“backward”(往回)\n"

#: misc-utils/findmnt.c:1219
msgid ""
" -e, --evaluate         convert tags (LABEL,UUID,PARTUUID,PARTLABEL) \n"
"                          to device names\n"
msgstr ""
" -e, --evaluate         将标签(LABEL,UUID,PARTUUID,PARTLABEL) 转换为\n"
"                          设备名\n"

#: misc-utils/findmnt.c:1221
msgid " -F, --tab-file <path>  alternative file for -s, -m or -k options\n"
msgstr " -F, --tab-file <路径>  -s, -m 或 -k 选项的替代文件\n"

#: misc-utils/findmnt.c:1222
msgid " -f, --first-only       print the first found filesystem only\n"
msgstr " -f, --first-only       只打印找到的第一个文件系统\n"

#: misc-utils/findmnt.c:1223
msgid " -i, --invert           invert the sense of matching\n"
msgstr " -i, --invert           反转搜索的匹配\n"

#: misc-utils/findmnt.c:1224 misc-utils/lslocks.c:501 sys-utils/lsns.c:901
#: sys-utils/rfkill.c:572
msgid " -J, --json             use JSON output format\n"
msgstr " -J, --json              使用 JSON 输出格式\n"

#: misc-utils/findmnt.c:1225 sys-utils/lsns.c:902
msgid " -l, --list             use list format output\n"
msgstr " -l, --list             使用列表格式的输出\n"

#: misc-utils/findmnt.c:1226
msgid " -N, --task <tid>       use alternative namespace (/proc/<tid>/mountinfo file)\n"
msgstr " -N, --task <tid>       使用替代的名字空间(/proc/<tid>/mountinfo 文件)\n"

#: misc-utils/findmnt.c:1227
msgid " -n, --noheadings       don't print column headings\n"
msgstr " -n, --noheadings       不打印列标题\n"

#: misc-utils/findmnt.c:1228
msgid " -O, --options <list>   limit the set of filesystems by mount options\n"
msgstr " -O, --options <列表>   根据挂臷选项限制文件系统集合\n"

#: misc-utils/findmnt.c:1229
msgid " -o, --output <list>    the output columns to be shown\n"
msgstr " -o, --output <列表>    要显示的列\n"

#: misc-utils/findmnt.c:1230
msgid " -P, --pairs            use key=\"value\" output format\n"
msgstr " -P, --pairs            使用 键=“值”的输出格式\n"

#: misc-utils/findmnt.c:1231
msgid " -R, --submounts        print all submounts for the matching filesystems\n"
msgstr " -R, --submounts        打印匹配文件系统的所有子挂载(submount)\n"

#: misc-utils/findmnt.c:1232
msgid " -r, --raw              use raw output format\n"
msgstr " -r, --raw              使用原生输出格式\n"

#: misc-utils/findmnt.c:1233
msgid ""
" -S, --source <string>  the device to mount (by name, maj:min, \n"
"                          LABEL=, UUID=, PARTUUID=, PARTLABEL=)\n"
msgstr ""
" -S, --source <字符串>  要挂载的设备(按 名称, 主:次设备号, \n"
"                          LABEL=, UUID=, PARTUUID=, PARTLABEL=)\n"

#: misc-utils/findmnt.c:1235
msgid " -T, --target <path>    the path to the filesystem to use\n"
msgstr " -T, --target <路径>    要使用的文件系统的路径\n"

#: misc-utils/findmnt.c:1236
#, fuzzy
msgid "     --tree             enable tree format output is possible\n"
msgstr " -l, --list             使用列表格式的输出\n"

#: misc-utils/findmnt.c:1237
msgid " -M, --mountpoint <dir> the mountpoint directory\n"
msgstr " -M, --mountpoint <目录> 挂载点目录\n"

#: misc-utils/findmnt.c:1238
msgid " -t, --types <list>     limit the set of filesystems by FS types\n"
msgstr " -t, --types <列表>     根据文件系统类型限制文件系统集合\n"

#: misc-utils/findmnt.c:1239
msgid " -U, --uniq             ignore filesystems with duplicate target\n"
msgstr " -U, --uniq             忽略目标重复的文件系统\n"

#: misc-utils/findmnt.c:1240 misc-utils/lslocks.c:507 sys-utils/lsns.c:907
msgid " -u, --notruncate       don't truncate text in columns\n"
msgstr " -u, --notruncate       不截断列中的文本\n"

#: misc-utils/findmnt.c:1241
msgid " -v, --nofsroot         don't print [/dir] for bind or btrfs mounts\n"
msgstr " -v, --nofsroot         对绑定式或 btrfs 挂载不打印[/dir]\n"

#: misc-utils/findmnt.c:1244
msgid " -x, --verify           verify mount table content (default is fstab)\n"
msgstr " -x, --verify           验证挂载表内容(默认为 fstab)\n"

#: misc-utils/findmnt.c:1245
msgid "     --verbose          print more details\n"
msgstr "     --verbose          打印更多细节\n"

#: misc-utils/findmnt.c:1373
#, c-format
msgid "unknown direction '%s'"
msgstr "未知方向“%s”"

#: misc-utils/findmnt.c:1445
msgid "invalid TID argument"
msgstr "无效的 TID 参数"

#: misc-utils/findmnt.c:1516
msgid "--poll accepts only one file, but more specified by --tab-file"
msgstr "--poll 只接受一个文件，但用 --tab-file 指定了多个"

#: misc-utils/findmnt.c:1520
msgid "options --target and --source can't be used together with command line element that is not an option"
msgstr "--target 和 --source 选项不能与非选项的命令行元素一起使用"

#: misc-utils/findmnt.c:1573
msgid "failed to initialize libmount cache"
msgstr "初始化 libmount 缓存失败"

#: misc-utils/findmnt.c:1616
#, c-format
msgid "%s column is requested, but --poll is not enabled"
msgstr "请示了 %s 列，但未启用 --poll"

#: misc-utils/findmnt-verify.c:116
msgid "target specified more than once"
msgstr "不止一次指定目标"

#: misc-utils/findmnt-verify.c:118
#, c-format
msgid "wrong order: %s specified before %s"
msgstr "顺序错误：%s 在 %s 之前指定"

#: misc-utils/findmnt-verify.c:132
msgid "undefined target (fs_file)"
msgstr "未定义目标 (fs_file)"

#: misc-utils/findmnt-verify.c:139
#, c-format
msgid "non-canonical target path (real: %s)"
msgstr "目标路径不规范(实为：%s)"

#: misc-utils/findmnt-verify.c:144
#, c-format
msgid "unreachable on boot required target: %m"
msgstr "启动所需目标无法访问：%m"

#: misc-utils/findmnt-verify.c:146
#, c-format
msgid "unreachable target: %m"
msgstr "不可及的目标: %m"

#: misc-utils/findmnt-verify.c:150
msgid "target is not a directory"
msgstr "目标不是一个目录"

#: misc-utils/findmnt-verify.c:152
msgid "target exists"
msgstr "目标存在"

#: misc-utils/findmnt-verify.c:164
#, c-format
msgid "unreachable on boot required source: %s=%s"
msgstr "启动所需的源无法访问：%s=%s"

#: misc-utils/findmnt-verify.c:166
#, c-format
msgid "unreachable: %s=%s"
msgstr "不可及: %s=%s"

#: misc-utils/findmnt-verify.c:168
#, c-format
msgid "%s=%s translated to %s"
msgstr "%s=%s 转换为 %s"

#: misc-utils/findmnt-verify.c:189
msgid "undefined source (fs_spec)"
msgstr "源未定义(fs_spec)"

#: misc-utils/findmnt-verify.c:198
#, c-format
msgid "unsupported source tag: %s"
msgstr "不受支持的源标记︰ %s"

#: misc-utils/findmnt-verify.c:205
#, c-format
msgid "do not check %s source (pseudo/net)"
msgstr "不检查 %s 源(pseudo/net)"

#: misc-utils/findmnt-verify.c:208
#, c-format
msgid "unreachable source: %s: %m"
msgstr "无法访问源︰ %s: %m"

#: misc-utils/findmnt-verify.c:211
#, c-format
msgid "non-bind mount source %s is a directory or regular file"
msgstr "非绑定挂载源 %s 是一个目录或常规文件"

#: misc-utils/findmnt-verify.c:214
#, c-format
msgid "source %s is not a block device"
msgstr "源 %s 不是一个块设备"

#: misc-utils/findmnt-verify.c:216
#, c-format
msgid "source %s exists"
msgstr "源 %s 已存在"

#: misc-utils/findmnt-verify.c:229
#, c-format
msgid "VFS options: %s"
msgstr "VFS 选项︰ %s"

#: misc-utils/findmnt-verify.c:233
#, c-format
msgid "FS options: %s"
msgstr "FS 选项︰ %s"

#: misc-utils/findmnt-verify.c:237
#, c-format
msgid "userspace options: %s"
msgstr "用户空间选项︰ %s"

#: misc-utils/findmnt-verify.c:251
#, c-format
msgid "unsupported swaparea discard policy: %s"
msgstr "不支持的 swaparea 放弃策略︰ %s"

#: misc-utils/findmnt-verify.c:259
msgid "failed to parse swaparea priority option"
msgstr "解析 swaparea 优先级选项失败"

#: misc-utils/findmnt-verify.c:395
#, c-format
msgid "do not check %s FS type (pseudo/net)"
msgstr "不检查 %s 文件系统类型 (pseudo/net)"

#: misc-utils/findmnt-verify.c:405
msgid "\"none\" FS type is recommended for bind or move oprations only"
msgstr "\"none\" 这种文件系统类型只建议用于绑定或移动操作"

#: misc-utils/findmnt-verify.c:413
#, fuzzy, c-format
msgid "%s seems unsupported by the current kernel"
msgstr "当前内核似乎不支持 %s"

#: misc-utils/findmnt-verify.c:419 misc-utils/findmnt-verify.c:420
msgid "cannot detect on-disk filesystem type"
msgstr "无法检测磁盘上(on-disk)的文件系统类型"

#: misc-utils/findmnt-verify.c:427
#, c-format
msgid "%s does not match with on-disk %s"
msgstr "%s 与磁盘上的 %s 不匹配"

#: misc-utils/findmnt-verify.c:430
#, fuzzy, c-format
msgid "on-disk %s seems unsupported by the current kernel"
msgstr "当前内核似乎不支持磁盘上的 %s"

#: misc-utils/findmnt-verify.c:432
#, c-format
msgid "FS type is %s"
msgstr "文件系统类型是 %s"

#: misc-utils/findmnt-verify.c:444
#, c-format
msgid "recommended root FS passno is 1 (current is %d)"
msgstr " 根文件系统的 passno 推荐值为 1 (当前是 %d)"

#: misc-utils/findmnt-verify.c:511
#, c-format
msgid "%d parse error"
msgid_plural "%d parse errors"
msgstr[0] "%d 个解析错误"

#: misc-utils/findmnt-verify.c:512
#, c-format
msgid ", %d error"
msgid_plural ", %d errors"
msgstr[0] "，%d 个错误"

#: misc-utils/findmnt-verify.c:513
#, c-format
msgid ", %d warning"
msgid_plural ", %d warnings"
msgstr[0] "，%d 个警告"

#: misc-utils/findmnt-verify.c:516
#, c-format
msgid "Success, no errors or warnings detected\n"
msgstr "成功，未检测到错误或警告\n"

#: misc-utils/getopt.c:302
msgid "empty long option after -l or --long argument"
msgstr "-l 或 --long 参数后的长选项为空"

#: misc-utils/getopt.c:323
msgid "unknown shell after -s or --shell argument"
msgstr "-s 或 --shell 参数后是未知的 shell"

#: misc-utils/getopt.c:330
#, c-format
msgid ""
" %1$s <optstring> <parameters>\n"
" %1$s [options] [--] <optstring> <parameters>\n"
" %1$s [options] -o|--options <optstring> [options] [--] <parameters>\n"
msgstr ""
" %1$s 选项字符串 参数\n"
" %1$s [options] [--] 选项字符串 参数\n"
" %1$s [options] -o|--options 选项字符串 [选项] [--] 参数\n"

#: misc-utils/getopt.c:336
msgid "Parse command options.\n"
msgstr "解析命令选项。 \n"

#: misc-utils/getopt.c:339
msgid " -a, --alternative             allow long options starting with single -\n"
msgstr " -a, --alternative             允许长选项以单个 - 开头\n"

#: misc-utils/getopt.c:340
msgid " -l, --longoptions <longopts>  the long options to be recognized\n"
msgstr " -l, --longoptions <longopts>  要识别的长选项\n"

#: misc-utils/getopt.c:341
msgid " -n, --name <progname>         the name under which errors are reported\n"
msgstr " -n, --name <progname>         要报告其错误的程序名称\n"

#: misc-utils/getopt.c:342
msgid " -o, --options <optstring>     the short options to be recognized\n"
msgstr " -o, --options <optstring>     要识别的短选项名称\n"

#: misc-utils/getopt.c:343
msgid " -q, --quiet                   disable error reporting by getopt(3)\n"
msgstr " -q, --quiet                   禁止 getopt(3) 的错误报告\n"

#: misc-utils/getopt.c:344
msgid " -Q, --quiet-output            no normal output\n"
msgstr " -Q, --quiet-output            无常规输出\n"

#: misc-utils/getopt.c:345
msgid " -s, --shell <shell>           set quoting conventions to those of <shell>\n"
msgstr " -s, --shell <shell>           设置 <shell> 的引用习惯\n"

#: misc-utils/getopt.c:346
msgid " -T, --test                    test for getopt(1) version\n"
msgstr " -T, --test                   getopt(1) 版本测试\n"

#: misc-utils/getopt.c:347
msgid " -u, --unquoted                do not quote the output\n"
msgstr " -u, --unquoted                不引用输出\n"

#: misc-utils/getopt.c:396 misc-utils/getopt.c:456
msgid "missing optstring argument"
msgstr "缺少 optstring 参数"

#: misc-utils/getopt.c:451
msgid "internal error, contact the author."
msgstr "内部错误，请联系作者。"

#: misc-utils/kill.c:151
#, c-format
msgid "unknown signal %s; valid signals:"
msgstr "未知信号 %s；有效信号为："

#: misc-utils/kill.c:176
#, c-format
msgid " %s [options] <pid>|<name>...\n"
msgstr " %s [选项] <pid>|<名称> ...\n"

#: misc-utils/kill.c:179
msgid "Forcibly terminate a process.\n"
msgstr "强制结束某个进程。\n"

#: misc-utils/kill.c:182
msgid ""
" -a, --all              do not restrict the name-to-pid conversion to processes\n"
"                          with the same uid as the present process\n"
msgstr ""
" -a, --all              不限于只对和当前进程的 uid 相同的进程进行\n"
"                          名称-pid 转换\n"

#: misc-utils/kill.c:184
msgid " -s, --signal <signal>  send this <signal> instead of SIGTERM\n"
msgstr " -s, --signal <信号>    发送指定的<信号>而非 SIGTERM\n"

#: misc-utils/kill.c:186
msgid " -q, --queue <value>    use sigqueue(2), not kill(2), and pass <value> as data\n"
msgstr " -q, --queue <值>       使用 sigqueue(2) 代替 kill(2)，并传递<值>数据\n"

#: misc-utils/kill.c:188
msgid " -p, --pid              print pids without signaling them\n"
msgstr " -p, --pid              打印 pid 而不向它们发送信号\n"

#: misc-utils/kill.c:189
msgid " -l, --list[=<signal>]  list signal names, or convert a signal number to a name\n"
msgstr " -l, --list [=<信号>]   列出信号名，或将一个信号数值转换为名称\n"

#: misc-utils/kill.c:190
msgid " -L, --table            list signal names and numbers\n"
msgstr " -L, --table            列出信号名和数值\n"

#: misc-utils/kill.c:191
msgid "     --verbose          print pids that will be signaled\n"
msgstr "     --verbose          打印将收到信号的 pid\n"

#: misc-utils/kill.c:240 misc-utils/kill.c:249 sys-utils/unshare.c:386
#, c-format
msgid "unknown signal: %s"
msgstr "未知信号：%s"

#: misc-utils/kill.c:260 misc-utils/kill.c:263 misc-utils/kill.c:272
#: misc-utils/kill.c:284 misc-utils/kill.c:307
#, c-format
msgid "%s and %s are mutually exclusive"
msgstr "%s 和 %s 相互排斥"

#: misc-utils/kill.c:287 sys-utils/eject.c:205 sys-utils/eject.c:230
#: sys-utils/losetup.c:707 sys-utils/tunelp.c:167 sys-utils/tunelp.c:174
#: sys-utils/tunelp.c:181 sys-utils/tunelp.c:188 sys-utils/tunelp.c:195
#: sys-utils/tunelp.c:201 sys-utils/tunelp.c:205 sys-utils/tunelp.c:212
#: term-utils/setterm.c:211 term-utils/setterm.c:214 term-utils/setterm.c:233
#: term-utils/setterm.c:235 term-utils/setterm.c:270 term-utils/setterm.c:272
#: term-utils/setterm.c:289 term-utils/setterm.c:296 term-utils/setterm.c:298
#: term-utils/setterm.c:310 term-utils/setterm.c:312 term-utils/setterm.c:321
#: term-utils/setterm.c:329 term-utils/setterm.c:344 term-utils/setterm.c:346
#: term-utils/setterm.c:358 term-utils/setterm.c:360 term-utils/setterm.c:371
#: term-utils/setterm.c:541 term-utils/setterm.c:546 term-utils/setterm.c:551
#: term-utils/setterm.c:556 term-utils/setterm.c:580 term-utils/setterm.c:585
#: term-utils/setterm.c:590 term-utils/setterm.c:595 term-utils/setterm.c:600
#: term-utils/setterm.c:605 term-utils/setterm.c:613 term-utils/setterm.c:646
msgid "argument error"
msgstr "参数出错"

#: misc-utils/kill.c:304
#, c-format
msgid "invalid signal name or number: %s"
msgstr "无效的信号名或数字：%s"

#: misc-utils/kill.c:321
#, c-format
msgid "sending signal %d to pid %d\n"
msgstr "将信号 %d 发送给 pid %d\n"

#: misc-utils/kill.c:334
#, c-format
msgid "sending signal to %s failed"
msgstr "向 %s 发送信号失败"

#: misc-utils/kill.c:380
#, c-format
msgid "cannot find process \"%s\""
msgstr "找不到进程“%s”"

#: misc-utils/logger.c:225
#, c-format
msgid "unknown facility name: %s"
msgstr "未知设施名称：%s"

#: misc-utils/logger.c:231
#, c-format
msgid "unknown priority name: %s"
msgstr "未知优先级名称：%s"

#: misc-utils/logger.c:243
#, c-format
msgid "openlog %s: pathname too long"
msgstr "openlog %s：路径名过长"

#: misc-utils/logger.c:270
#, c-format
msgid "socket %s"
msgstr "套接字 %s"

#: misc-utils/logger.c:307
#, c-format
msgid "failed to resolve name %s port %s: %s"
msgstr "解析名称 %s 端口 %s 失败：%s"

#: misc-utils/logger.c:324
#, c-format
msgid "failed to connect to %s port %s"
msgstr "连接 %s 端口 %s 失败"

#: misc-utils/logger.c:353
#, c-format
msgid "maximum input lines (%d) exceeded"
msgstr "超过了最大输入行数(%d)"

#: misc-utils/logger.c:505
msgid "send message failed"
msgstr "发送消息失败"

#: misc-utils/logger.c:575
#, c-format
msgid "structured data ID '%s' is not unique"
msgstr "结构化数据的 ID “%s” 不唯一"

#: misc-utils/logger.c:589
#, c-format
msgid "--sd-id was not specified for --sd-param %s"
msgstr "没有为 --sd-param %s 指定 --sd-id"

#: misc-utils/logger.c:768
msgid "localtime() failed"
msgstr "localtime() 失败"

#: misc-utils/logger.c:778
#, c-format
msgid "hostname '%s' is too long"
msgstr "主机名“'%s”太长"

#: misc-utils/logger.c:784
#, c-format
msgid "tag '%s' is too long"
msgstr "标签“%s”太长"

#: misc-utils/logger.c:847
#, c-format
msgid "ignoring unknown option argument: %s"
msgstr "将忽略未知的选项参数：%s"

#: misc-utils/logger.c:859
#, c-format
msgid "invalid argument: %s: using automatic errors"
msgstr "无效参数︰ %s︰ 将使用自动错误"

#: misc-utils/logger.c:1030
#, c-format
msgid " %s [options] [<message>]\n"
msgstr " %s [选项] [<消息>]\n"

#: misc-utils/logger.c:1033
msgid "Enter messages into the system log.\n"
msgstr "将消息输入系统日志。\n"

#: misc-utils/logger.c:1036
msgid " -i                       log the logger command's PID\n"
msgstr " -i                       记录日志程序的 PID\n"

#: misc-utils/logger.c:1037
msgid "     --id[=<id>]          log the given <id>, or otherwise the PID\n"
msgstr "     --id[=<id>]          记录指定的 <id>，否则记录 PID\n"

#: misc-utils/logger.c:1038
msgid " -f, --file <file>        log the contents of this file\n"
msgstr " -f, --file <文件>       记录指定文件的内容\n"

#: misc-utils/logger.c:1039
msgid " -e, --skip-empty         do not log empty lines when processing files\n"
msgstr " -e, --skip-empty         处理文件时不记录空行\n"

#: misc-utils/logger.c:1040
msgid "     --no-act             do everything except the write the log\n"
msgstr "     --no-act             操作但不实际写入日志\n"

#: misc-utils/logger.c:1041
msgid " -p, --priority <prio>    mark given message with this priority\n"
msgstr " -p, --priority <prio>    将指定消息标记为此优先级\n"

#: misc-utils/logger.c:1042
msgid "     --octet-count        use rfc6587 octet counting\n"
msgstr "     --octet-count        使用 rfc6587 八位元组(octet) 计数\n"

#: misc-utils/logger.c:1043
msgid "     --prio-prefix        look for a prefix on every line read from stdin\n"
msgstr "     --prio-prefix        从 stdin 输入的每一行查找前缀\n"

#: misc-utils/logger.c:1044
msgid " -s, --stderr             output message to standard error as well\n"
msgstr " -s, --stderr             也向标准错误输出消息\n"

#: misc-utils/logger.c:1045
msgid " -S, --size <size>        maximum size for a single message\n"
msgstr " -S, --size <大小>        单条消息的最大尺寸\n"

#: misc-utils/logger.c:1046
msgid " -t, --tag <tag>          mark every line with this tag\n"
msgstr " -t, --tag <tag>          向每一行添加指定标记\n"

#: misc-utils/logger.c:1047
msgid " -n, --server <name>      write to this remote syslog server\n"
msgstr " -n, --server <名称>      写入指定的远程 syslog 服务器\n"

#: misc-utils/logger.c:1048
msgid " -P, --port <port>        use this port for UDP or TCP connection\n"
msgstr " -P, --port <端口>        使用指定端口进行 UDP 或 TCP 连接\n"

#: misc-utils/logger.c:1049
msgid " -T, --tcp                use TCP only\n"
msgstr " -T, --tcp                只用 TCP\n"

#: misc-utils/logger.c:1050
msgid " -d, --udp                use UDP only\n"
msgstr " -d, --udp                只用 UDP\n"

#: misc-utils/logger.c:1051
msgid "     --rfc3164            use the obsolete BSD syslog protocol\n"
msgstr "     --rfc3164            使用过时的 BSD syslog 协议\n"

#: misc-utils/logger.c:1052
msgid ""
"     --rfc5424[=<snip>]   use the syslog protocol (the default for remote);\n"
"                            <snip> can be notime, or notq, and/or nohost\n"
msgstr ""
"     --rfc5424[=<snip>]   使用 syslog 协议(远程时默认);\n"
"                            <snip> 可以是 notime, 或 notq, 和/或 nohost\n"

#: misc-utils/logger.c:1054
msgid "     --sd-id <id>         rfc5424 structured data ID\n"
msgstr "     --sd-id <id>         rfc5424 结构化数据 ID\n"

#: misc-utils/logger.c:1055
msgid "     --sd-param <data>    rfc5424 structured data name=value\n"
msgstr "     --sd-param <数据>    rfc5424 结构化数据名称=值\n"

#: misc-utils/logger.c:1056
msgid "     --msgid <msgid>      set rfc5424 message id field\n"
msgstr "     --msgid <msgid>      设置 rfc5424 消息 id 字段\n"

#: misc-utils/logger.c:1057
msgid " -u, --socket <socket>    write to this Unix socket\n"
msgstr " -u, --socket <套接字>    写入此 Unix 套接字\n"

#: misc-utils/logger.c:1058
msgid ""
"     --socket-errors[=<on|off|auto>]\n"
"                          print connection errors when using Unix sockets\n"
msgstr ""
"     --socket-errors[=<on|off|auto>]\n"
"                          使用 Unix 套接字时打印连接错误\n"

#: misc-utils/logger.c:1061
msgid "     --journald[=<file>]  write journald entry\n"
msgstr "     --journald[=<文件>]  写 journald 记录\n"

#: misc-utils/logger.c:1147
#, c-format
msgid "file %s"
msgstr "文件 %s"

#: misc-utils/logger.c:1162
msgid "failed to parse id"
msgstr "解析 id 失败"

#: misc-utils/logger.c:1180
msgid "failed to parse message size"
msgstr "解析消息大小失败"

#: misc-utils/logger.c:1215
msgid "--msgid cannot contain space"
msgstr "--msgid 不能包含空格"

#: misc-utils/logger.c:1237
#, c-format
msgid "invalid structured data ID: '%s'"
msgstr "无效的结构化数据 ID: “%s”"

#: misc-utils/logger.c:1242
#, c-format
msgid "invalid structured data parameter: '%s'"
msgstr "无效的结构化数据参数: “%s”"

#: misc-utils/logger.c:1252
msgid "--file <file> and <message> are mutually exclusive, message is ignored"
msgstr "--file <文件> 和 <消息> 互斥，消息已忽略"

#: misc-utils/logger.c:1259
msgid "journald entry could not be written"
msgstr "无法写入 journald 项"

#: misc-utils/look.c:360
#, c-format
msgid " %s [options] <string> [<file>...]\n"
msgstr " %s [选项] <字符串> [<文件>...]\n"

#: misc-utils/look.c:363
msgid "Display lines beginning with a specified string.\n"
msgstr "显示以指定字符串开头的行。\n"

#: misc-utils/look.c:366
msgid " -a, --alternative        use the alternative dictionary\n"
msgstr " -a, --alternative        使用替代字典\n"

#: misc-utils/look.c:367
msgid " -d, --alphanum           compare only blanks and alphanumeric characters\n"
msgstr " -d, --alphanum           只比较空白和字母数字字符\n"

#: misc-utils/look.c:368
msgid " -f, --ignore-case        ignore case differences when comparing\n"
msgstr " -f, --ignore-case        比较时忽略大小写\n"

#: misc-utils/look.c:369
msgid " -t, --terminate <char>   define the string-termination character\n"
msgstr " -t, --terminate <字符>   定义字符串终止字符\n"

#: misc-utils/lsblk.c:162
msgid "device name"
msgstr "设备名"

#: misc-utils/lsblk.c:163
msgid "internal kernel device name"
msgstr "内部内核设备名称"

#: misc-utils/lsblk.c:164
msgid "internal parent kernel device name"
msgstr "内部上级内核设备名称"

#: misc-utils/lsblk.c:167 sys-utils/zramctl.c:86
msgid "where the device is mounted"
msgstr "设备挂载位置"

#: misc-utils/lsblk.c:168 misc-utils/wipefs.c:104
msgid "filesystem LABEL"
msgstr "文件系统标签"

#: misc-utils/lsblk.c:171
msgid "partition type UUID"
msgstr "分区类型 UUID"

#: misc-utils/lsblk.c:172
msgid "partition LABEL"
msgstr "分区 LABEL"

#: misc-utils/lsblk.c:176
msgid "read-ahead of the device"
msgstr "该设备的预读(read-ahead)"

#: misc-utils/lsblk.c:177 sys-utils/losetup.c:77
msgid "read-only device"
msgstr "只读设备"

#: misc-utils/lsblk.c:178
msgid "removable device"
msgstr "可移动设备"

#: misc-utils/lsblk.c:179
msgid "removable or hotplug device (usb, pcmcia, ...)"
msgstr "可移动或热插拔设备(usb, pcmcia, ...)"

#: misc-utils/lsblk.c:180
msgid "rotational device"
msgstr "转动设备"

#: misc-utils/lsblk.c:181
msgid "adds randomness"
msgstr "添加随机性"

#: misc-utils/lsblk.c:182
msgid "device identifier"
msgstr "设备标识符"

#: misc-utils/lsblk.c:183
msgid "disk serial number"
msgstr "磁盘序列号"

#: misc-utils/lsblk.c:184
msgid "size of the device"
msgstr "磁盘容量"

#: misc-utils/lsblk.c:185
msgid "state of the device"
msgstr "设备的状态"

#: misc-utils/lsblk.c:187
msgid "group name"
msgstr "组名"

#: misc-utils/lsblk.c:188
msgid "device node permissions"
msgstr "设备节点权限"

#: misc-utils/lsblk.c:189
msgid "alignment offset"
msgstr "对齐偏移量"

#: misc-utils/lsblk.c:190
msgid "minimum I/O size"
msgstr "最小 I/O 大小"

#: misc-utils/lsblk.c:191
msgid "optimal I/O size"
msgstr "最优 I/O 大小"

#: misc-utils/lsblk.c:192
msgid "physical sector size"
msgstr "物理扇区大小"

#: misc-utils/lsblk.c:193
msgid "logical sector size"
msgstr "逻辑扇区大小"

#: misc-utils/lsblk.c:194
msgid "I/O scheduler name"
msgstr "I/O 调度器名称"

#: misc-utils/lsblk.c:195
msgid "request queue size"
msgstr "请求队列大小"

#: misc-utils/lsblk.c:196
msgid "device type"
msgstr "设备类型"

#: misc-utils/lsblk.c:197
msgid "discard alignment offset"
msgstr "忽略对齐偏移量"

#: misc-utils/lsblk.c:198
msgid "discard granularity"
msgstr "忽略粒度"

#: misc-utils/lsblk.c:199
msgid "discard max bytes"
msgstr "忽略最大字节数"

#: misc-utils/lsblk.c:200
msgid "discard zeroes data"
msgstr "忽略零数据"

#: misc-utils/lsblk.c:201
msgid "write same max bytes"
msgstr "写相同的最大字节数"

#: misc-utils/lsblk.c:202
msgid "unique storage identifier"
msgstr "惟一存储标识符"

#: misc-utils/lsblk.c:203
msgid "Host:Channel:Target:Lun for SCSI"
msgstr "SCSI 的 Host:Channel:Target:Lun"

#: misc-utils/lsblk.c:204
msgid "device transport type"
msgstr "设备传输类型"

#: misc-utils/lsblk.c:205
msgid "de-duplicated chain of subsystems"
msgstr "对成链的子系统去重"

#: misc-utils/lsblk.c:206
msgid "device revision"
msgstr "设备修订版本"

#: misc-utils/lsblk.c:207
msgid "device vendor"
msgstr "设备制造商"

#: misc-utils/lsblk.c:208
msgid "zone model"
msgstr ""

#: misc-utils/lsblk.c:1292
msgid "failed to open device directory in sysfs"
msgstr "打开 sysfs 中的设备目录失败"

#: misc-utils/lsblk.c:1478
#, c-format
msgid "%s: failed to compose sysfs path"
msgstr "%s：组成 sysfs 路径失败"

#: misc-utils/lsblk.c:1484
#, c-format
msgid "%s: failed to read link"
msgstr "%s：读链接失败"

#: misc-utils/lsblk.c:1506
#, c-format
msgid "%s: failed to get sysfs name"
msgstr "%s：获取 sysfs 名称失败"

#: misc-utils/lsblk.c:1515
#, c-format
msgid "%s: failed to get whole-disk device number"
msgstr "%s：获取 整盘 设备号失败"

#: misc-utils/lsblk.c:1567 misc-utils/lsblk.c:1569 misc-utils/lsblk.c:1594
#: misc-utils/lsblk.c:1596
#, c-format
msgid "failed to parse list '%s'"
msgstr "解析列表“%s”失败"

#. TRANSLATORS: The standard value for %d is 256.
#: misc-utils/lsblk.c:1574
#, c-format
msgid "the list of excluded devices is too large (limit is %d devices)"
msgstr "排除设备列表过大(限制为 %d 台设备)"

#. TRANSLATORS: The standard value for %d is 256.
#: misc-utils/lsblk.c:1601
#, c-format
msgid "the list of included devices is too large (limit is %d devices)"
msgstr "包含设备列表过大(限制为 %d 台设备)"

#: misc-utils/lsblk.c:1633 sys-utils/wdctl.c:175
#, c-format
msgid " %s [options] [<device> ...]\n"
msgstr " %s [选项] [<设备> ...]\n"

#: misc-utils/lsblk.c:1636
msgid "List information about block devices.\n"
msgstr "列出块设备的信息。\n"

#: misc-utils/lsblk.c:1639
msgid " -a, --all            print all devices\n"
msgstr " -a, --all            打印所有设备\n"

#: misc-utils/lsblk.c:1641
msgid " -d, --nodeps         don't print slaves or holders\n"
msgstr " -d, --nodeps         不打印从属设备(slave)或占位设备(holder)\n"

#: misc-utils/lsblk.c:1642
msgid " -D, --discard        print discard capabilities\n"
msgstr " -D, --discard        打印时丢弃能力\n"

#: misc-utils/lsblk.c:1643
#, fuzzy
msgid " -z, --zoned          print zone model\n"
msgstr " -c, --offline           只打印离线 CPU\n"

#: misc-utils/lsblk.c:1644
msgid " -e, --exclude <list> exclude devices by major number (default: RAM disks)\n"
msgstr " -e, --exclude <列表> 根据主设备号排除设备(默认：内存盘)\n"

#: misc-utils/lsblk.c:1645
msgid " -f, --fs             output info about filesystems\n"
msgstr " -f, --fs             输出文件系统信息\n"

#: misc-utils/lsblk.c:1646
msgid " -i, --ascii          use ascii characters only\n"
msgstr " -i, --ascii          只使用 ascii 字符\n"

#: misc-utils/lsblk.c:1647
msgid " -I, --include <list> show only devices with specified major numbers\n"
msgstr " -I, --include <列表> 只显示有指定主设备号的设备\n"

#: misc-utils/lsblk.c:1648 sys-utils/lsmem.c:502
msgid " -J, --json           use JSON output format\n"
msgstr " -J, --json           使用 JSON 输出格式\n"

#: misc-utils/lsblk.c:1649
msgid " -l, --list           use list format output\n"
msgstr " -l, --list           使用列表格式的输出\n"

#: misc-utils/lsblk.c:1650
#, fuzzy
msgid " -T, --tree           use tree format output\n"
msgstr " -l, --list           使用列表格式的输出\n"

#: misc-utils/lsblk.c:1651
msgid " -m, --perms          output info about permissions\n"
msgstr " -m, --perms          输出权限信息\n"

#: misc-utils/lsblk.c:1652 sys-utils/lsmem.c:506
msgid " -n, --noheadings     don't print headings\n"
msgstr " -n, --noheadings     不打印标题\n"

#: misc-utils/lsblk.c:1653 sys-utils/lsmem.c:507
msgid " -o, --output <list>  output columns\n"
msgstr " -o, --output <列表>  输出列\n"

#: misc-utils/lsblk.c:1654
msgid " -O, --output-all     output all columns\n"
msgstr " -O, --output-all     输出所有列\n"

#: misc-utils/lsblk.c:1655
msgid " -p, --paths          print complete device path\n"
msgstr " -p, --paths          打印完整设备路径\n"

#: misc-utils/lsblk.c:1658
msgid " -s, --inverse        inverse dependencies\n"
msgstr " -s, --inverse        反向依赖\n"

#: misc-utils/lsblk.c:1659
msgid " -S, --scsi           output info about SCSI devices\n"
msgstr " -S, --scsi           输出有关 SCSI 设备的信息\n"

#: misc-utils/lsblk.c:1660
msgid " -t, --topology       output info about topology\n"
msgstr " -t, --topology       输出拓扑信息\n"

#: misc-utils/lsblk.c:1661
msgid " -x, --sort <column>  sort output by <column>\n"
msgstr " -x, --sort <列>      按<列>对输出排序\n"

#: misc-utils/lsblk.c:1678
#, c-format
msgid "failed to access sysfs directory: %s"
msgstr "无法访问 sysfs 目录：%s"

#: misc-utils/lslocks.c:73
msgid "command of the process holding the lock"
msgstr "持有锁的进程命令"

#: misc-utils/lslocks.c:74
msgid "PID of the process holding the lock"
msgstr "持有锁的进程 PID"

#: misc-utils/lslocks.c:75
#, fuzzy
msgid "kind of lock"
msgstr "锁的大小"

#: misc-utils/lslocks.c:76
msgid "size of the lock"
msgstr "锁的大小"

#: misc-utils/lslocks.c:77
msgid "lock access mode"
msgstr "锁访问模式"

#: misc-utils/lslocks.c:78
msgid "mandatory state of the lock: 0 (none), 1 (set)"
msgstr "锁的强制(mandatory)状态：0(未设置)，1(设置)"

#: misc-utils/lslocks.c:79
msgid "relative byte offset of the lock"
msgstr "锁的相对字节偏移量"

#: misc-utils/lslocks.c:80
msgid "ending offset of the lock"
msgstr "锁的末尾偏移量"

#: misc-utils/lslocks.c:81
msgid "path of the locked file"
msgstr "锁定文件的路径"

#: misc-utils/lslocks.c:82
msgid "PID of the process blocking the lock"
msgstr "阻塞锁的进程的 PID"

#: misc-utils/lslocks.c:259
msgid "failed to parse ID"
msgstr "解析 ID 失败"

#: misc-utils/lslocks.c:281 sys-utils/nsenter.c:264
msgid "failed to parse pid"
msgstr "解析 pid 失败"

#: misc-utils/lslocks.c:284
msgid "(unknown)"
msgstr "(未知)"

#: misc-utils/lslocks.c:293
msgid "failed to parse start"
msgstr "解析 起点 失败"

#: misc-utils/lslocks.c:300
msgid "failed to parse end"
msgstr "解析 终点 失败"

#: misc-utils/lslocks.c:498
msgid "List local system locks.\n"
msgstr "列出本地系统锁。\n"

#: misc-utils/lslocks.c:502
msgid " -i, --noinaccessible   ignore locks without read permissions\n"
msgstr " -i, --noinaccessible   忽略没有读权限的锁\n"

#: misc-utils/lslocks.c:503 sys-utils/lsns.c:903 sys-utils/rfkill.c:573
msgid " -n, --noheadings       don't print headings\n"
msgstr " -n, --noheadings       不打印标题\n"

#: misc-utils/lslocks.c:504 sys-utils/lsns.c:904 sys-utils/rfkill.c:574
msgid " -o, --output <list>    define which output columns to use\n"
msgstr " -o, --output <list>    定义使用哪个输出列\n"

#: misc-utils/lslocks.c:505
msgid " -p, --pid <pid>        display only locks held by this process\n"
msgstr " -p, --pid <pid>        只显示由指定进程持有的锁\n"

#: misc-utils/lslocks.c:506 sys-utils/lsns.c:906 sys-utils/rfkill.c:575
msgid " -r, --raw              use the raw output format\n"
msgstr " -r, --raw              使用原生输出格式\n"

#: misc-utils/lslocks.c:563 schedutils/chrt.c:475 schedutils/ionice.c:177
#: schedutils/taskset.c:171 sys-utils/lsns.c:983 sys-utils/prlimit.c:585
msgid "invalid PID argument"
msgstr "无效的 PID 参数"

#: misc-utils/mcookie.c:86
msgid "Generate magic cookies for xauth.\n"
msgstr "为 xauth 生成 magic cookies。\n"

#: misc-utils/mcookie.c:89
msgid " -f, --file <file>     use file as a cookie seed\n"
msgstr " -f, --file <文件>     用指定文件作为 cookie 种子\n"

#: misc-utils/mcookie.c:90
msgid " -m, --max-size <num>  limit how much is read from seed files\n"
msgstr " -m, --max-size <数字> 限制从种子文件读取的大小\n"

#: misc-utils/mcookie.c:91
msgid " -v, --verbose         explain what is being done\n"
msgstr " -v, --verbose         解释正在进行的操作\n"

#: misc-utils/mcookie.c:120
#, c-format
msgid "Got %zu byte from %s\n"
msgid_plural "Got %zu bytes from %s\n"
msgstr[0] "从 %2$s 获得 %1$zu 字节\n"

#: misc-utils/mcookie.c:125
#, c-format
msgid "closing %s failed"
msgstr "关闭 %s 失败"

#: misc-utils/mcookie.c:164 sys-utils/blkdiscard.c:146 sys-utils/fstrim.c:310
#: text-utils/hexdump.c:117
msgid "failed to parse length"
msgstr "解析长度失败"

#: misc-utils/mcookie.c:177
msgid "--max-size ignored when used without --file"
msgstr "不带 --file 时忽略 --max-size"

#: misc-utils/mcookie.c:186
#, c-format
msgid "Got %d byte from %s\n"
msgid_plural "Got %d bytes from %s\n"
msgstr[0] "从 %2$s 获取到 %1$d 字节\n"

#: misc-utils/namei.c:90
#, c-format
msgid "failed to read symlink: %s"
msgstr "读符号链接失败：%s"

#: misc-utils/namei.c:283
#, c-format
msgid "%s - No such file or directory\n"
msgstr "%s - 无此文件或目录\n"

#: misc-utils/namei.c:333
#, c-format
msgid " %s [options] <pathname>...\n"
msgstr " %s [选项] <路径名> ...\n"

#: misc-utils/namei.c:336
msgid "Follow a pathname until a terminal point is found.\n"
msgstr "沿路径寻找，直到某个终止点为止。\n"

#: misc-utils/namei.c:340
#, fuzzy
msgid ""
" -x, --mountpoints   show mount point directories with a 'D'\n"
" -m, --modes         show the mode bits of each file\n"
" -o, --owners        show owner and group name of each file\n"
" -l, --long          use a long listing format (-m -o -v) \n"
" -n, --nosymlinks    don't follow symlinks\n"
" -v, --vertical      vertical align of modes and owners\n"
msgstr ""
" -h, --help          显示此帮助文字\n"
" -V, --version       输出版本信息并退出\n"
" -x, --mountpoints   用“D”显示挂载点目录\n"
" -m, --modes         显示每个文件的模式位\n"
" -o, --owners        显示每个文件的拥有者和组名\n"
" -l, --long          使用长列表格式 (-m -o -v) \n"
" -n, --nosymlinks    不显示符号链接\n"
" -v, --vertical      竖直对齐 模式 和 拥有者\n"

#: misc-utils/namei.c:408
msgid "pathname argument is missing"
msgstr "缺少 路径名 参数"

#: misc-utils/namei.c:414 sys-utils/lsns.c:1057
msgid "failed to allocate UID cache"
msgstr "分配 UID 缓存失败"

#: misc-utils/namei.c:417
msgid "failed to allocate GID cache"
msgstr "分配 GID 缓存失败"

#: misc-utils/namei.c:439
#, c-format
msgid "%s: exceeded limit of symlinks"
msgstr "%s：超过了符号链接限制"

#: misc-utils/rename.c:67
#, c-format
msgid "%s: not a symbolic link"
msgstr "%s：不是符号链接"

#: misc-utils/rename.c:72
#, c-format
msgid "%s: readlink failed"
msgstr "%s：readlink 失败"

#: misc-utils/rename.c:82
#, c-format
msgid "Skipping existing link: `%s'\n"
msgstr ""

#: misc-utils/rename.c:89
#, c-format
msgid "%s: unlink failed"
msgstr "%s：unlink 失败"

#: misc-utils/rename.c:92
#, c-format
msgid "%s: symlinking to %s failed"
msgstr "%s：符号链接到 %s 失败"

#: misc-utils/rename.c:116
#, fuzzy, c-format
msgid "Skipping existing file: `%s'\n"
msgstr "...跳到文件 "

#: misc-utils/rename.c:120
#, c-format
msgid "%s: rename to %s failed"
msgstr "%s：重命名为 %s 失败"

#: misc-utils/rename.c:134
#, c-format
msgid " %s [options] <expression> <replacement> <file>...\n"
msgstr " %s [选项] <表达式> <替换> <文件>...\n"

#: misc-utils/rename.c:138
msgid "Rename files.\n"
msgstr "重命名文件。\n"

#: misc-utils/rename.c:141
#, fuzzy
msgid " -v, --verbose       explain what is being done\n"
msgstr " -v, --verbose         解释正在进行的操作\n"

#: misc-utils/rename.c:142
#, fuzzy
msgid " -s, --symlink       act on the target of symlinks\n"
msgstr " -s, --symlink    在符号链接的目标上执行\n"

#: misc-utils/rename.c:143
#, fuzzy
msgid " -n, --no-act        do not make any changes\n"
msgstr " -n, --noheadings     不打印标题\n"

#: misc-utils/rename.c:144
msgid " -o, --no-overwrite  don't overwrite existing files\n"
msgstr ""

#: misc-utils/uuidd.c:64
msgid "A daemon for generating UUIDs.\n"
msgstr "一个用于生成 UUID 的守护进程。\n"

#: misc-utils/uuidd.c:66
msgid " -p, --pid <path>        path to pid file\n"
msgstr " -p, --pid <路径>        pid 文件路径\n"

#: misc-utils/uuidd.c:67
msgid " -s, --socket <path>     path to socket\n"
msgstr " -s, --socket <路径>     套接字路径\n"

#: misc-utils/uuidd.c:68
msgid " -T, --timeout <sec>     specify inactivity timeout\n"
msgstr " -T, --timeout <秒>    指定无活动超时\n"

#: misc-utils/uuidd.c:69
msgid " -k, --kill              kill running daemon\n"
msgstr " -k, --kill              杀死运行中的守护进程\n"

#: misc-utils/uuidd.c:70
msgid " -r, --random            test random-based generation\n"
msgstr " -r, --random            测试基于随机数的生成方式\n"

#: misc-utils/uuidd.c:71
msgid " -t, --time              test time-based generation\n"
msgstr " -t, --time              测试基于时间的生成方式\n"

#: misc-utils/uuidd.c:72
msgid " -n, --uuids <num>       request number of uuids\n"
msgstr " -n, --uuids <数值>       请求指定数量的 uuid\n"

#: misc-utils/uuidd.c:73
msgid " -P, --no-pid            do not create pid file\n"
msgstr " -P, --no-pid            不创建 pid 文件\n"

#: misc-utils/uuidd.c:74
msgid " -F, --no-fork           do not daemonize using double-fork\n"
msgstr " -F, --no-fork           不使用双 fork 变成守护进程\n"

#: misc-utils/uuidd.c:75
msgid " -S, --socket-activation do not create listening socket\n"
msgstr " -S, --socket-activation 不创建侦听套接字\n"

#: misc-utils/uuidd.c:76
msgid " -d, --debug             run in debugging mode\n"
msgstr " -d, --debug             以调试模式运行\n"

#: misc-utils/uuidd.c:77
msgid " -q, --quiet             turn on quiet mode\n"
msgstr " -q, --quiet             开启安静模式\n"

#: misc-utils/uuidd.c:109
msgid "bad arguments"
msgstr "参数错误"

#: misc-utils/uuidd.c:116
msgid "socket"
msgstr "套接字"

#: misc-utils/uuidd.c:127
msgid "connect"
msgstr "连接"

#: misc-utils/uuidd.c:147
msgid "write"
msgstr "写"

#: misc-utils/uuidd.c:155
msgid "read count"
msgstr "读计数"

#: misc-utils/uuidd.c:161
msgid "bad response length"
msgstr "响应长度错误"

#: misc-utils/uuidd.c:212
#, c-format
msgid "cannot lock %s"
msgstr "无法锁定 %s"

#: misc-utils/uuidd.c:237
msgid "couldn't create unix stream socket"
msgstr "无法创建 unix 流套接字"

#: misc-utils/uuidd.c:262
#, c-format
msgid "couldn't bind unix socket %s"
msgstr "无法绑定 unix 套接字 %s"

#: misc-utils/uuidd.c:289
msgid "receiving signal failed"
msgstr "接收信号失败"

#: misc-utils/uuidd.c:302
msgid "timed out"
msgstr "已超时"

#: misc-utils/uuidd.c:336 sys-utils/flock.c:272
msgid "cannot set up timer"
msgstr "无法设置定时器"

#: misc-utils/uuidd.c:344
#, c-format
msgid "uuidd daemon is already running at pid %s"
msgstr "uuidd 守护进程已运行，pid 为 %s"

#: misc-utils/uuidd.c:353
#, c-format
msgid "couldn't listen on unix socket %s"
msgstr "无法侦听 unix 套接字 %s"

#: misc-utils/uuidd.c:363
#, c-format
msgid "could not truncate file: %s"
msgstr "无法截短文件：%s"

#: misc-utils/uuidd.c:377
msgid "sd_listen_fds() failed"
msgstr "sd_listen_fds() 失败"

#: misc-utils/uuidd.c:380
msgid "no file descriptors received, check systemctl status uuidd.socket"
msgstr "没有收到文件描述符，请检查 systemctl 状态 uuidd.socket"

#: misc-utils/uuidd.c:383
msgid "too many file descriptors received, check uuidd.socket"
msgstr "收到太多文件描述符，请检查 uuidd.socket"

#: misc-utils/uuidd.c:416
#, c-format
msgid "timeout [%d sec]\n"
msgstr "超时 [%d 秒]\n"

#: misc-utils/uuidd.c:434 term-utils/setterm.c:899 text-utils/column.c:496
#: text-utils/column.c:529
msgid "read failed"
msgstr "read 失败"

#: misc-utils/uuidd.c:436
#, c-format
msgid "error reading from client, len = %d"
msgstr "从客户端读取出错，长度 = %d"

#: misc-utils/uuidd.c:445
#, c-format
msgid "operation %d, incoming num = %d\n"
msgstr "操作 %d，接收数 = %d\n"

#: misc-utils/uuidd.c:448
#, c-format
msgid "operation %d\n"
msgstr "操作 %d\n"

#: misc-utils/uuidd.c:464
#, c-format
msgid "Generated time UUID: %s\n"
msgstr "已生成时间 UUID：%s\n"

#: misc-utils/uuidd.c:474
#, c-format
msgid "Generated random UUID: %s\n"
msgstr "已生成随机 UUID：%s\n"

#: misc-utils/uuidd.c:483
#, c-format
msgid "Generated time UUID %s and %d following\n"
msgid_plural "Generated time UUID %s and %d following\n"
msgstr[0] "已生成时间 UUID %s 和后续 %d 个\n"

#: misc-utils/uuidd.c:504
#, c-format
msgid "Generated %d UUID:\n"
msgid_plural "Generated %d UUIDs:\n"
msgstr[0] "已生成 %d 个 UUID：\n"

#: misc-utils/uuidd.c:518
#, c-format
msgid "Invalid operation %d\n"
msgstr "无效操作 %d\n"

#: misc-utils/uuidd.c:530
#, c-format
msgid "Unexpected reply length from server %d"
msgstr "服务器 %d 响应长度异常"

#: misc-utils/uuidd.c:591
msgid "failed to parse --uuids"
msgstr "解析 --uuids 失败"

#: misc-utils/uuidd.c:608
msgid "uuidd has been built without support for socket activation"
msgstr "uuidd 构建时没有添加套接字激活支持"

#: misc-utils/uuidd.c:627
msgid "failed to parse --timeout"
msgstr "解析 --timeout 失败"

#: misc-utils/uuidd.c:640
#, fuzzy, c-format
msgid "socket name too long: %s"
msgstr "卷名过长"

#: misc-utils/uuidd.c:647
msgid "Both --socket-activation and --socket specified. Ignoring --socket."
msgstr "同时指定了 --socket-activation 和 --socket。将忽略 --socket"

#: misc-utils/uuidd.c:654 misc-utils/uuidd.c:682
#, c-format
msgid "error calling uuidd daemon (%s)"
msgstr "调用 uuidd 守护进程(%s)出错"

#: misc-utils/uuidd.c:655 misc-utils/uuidd.c:683
msgid "unexpected error"
msgstr "意外错误"

#: misc-utils/uuidd.c:663
#, c-format
msgid "%s and %d subsequent UUID\n"
msgid_plural "%s and %d subsequent UUIDs\n"
msgstr[0] "%s 和 %d 个后续 UUID\n"

#: misc-utils/uuidd.c:667
#, c-format
msgid "List of UUIDs:\n"
msgstr "UUID 列表：\n"

#: misc-utils/uuidd.c:699
#, c-format
msgid "couldn't kill uuidd running at pid %d"
msgstr "无法运行 pid 为 %d 的 uuidd"

#: misc-utils/uuidd.c:704
#, c-format
msgid "Killed uuidd running at pid %d.\n"
msgstr "已杀死运行 pid 为 %d 的 uuidd。\n"

#: misc-utils/uuidgen.c:29
msgid "Create a new UUID value.\n"
msgstr "创建新的 UUID 值。\n"

#: misc-utils/uuidgen.c:32
#, fuzzy
msgid " -r, --random        generate random-based uuid\n"
msgstr " -r, --random            测试基于随机数的生成方式\n"

#: misc-utils/uuidgen.c:33
#, fuzzy
msgid " -t, --time          generate time-based uuid\n"
msgstr " -t, --time              测试基于时间的生成方式\n"

#: misc-utils/uuidgen.c:34
msgid " -n, --namespace ns  generate hash-based uuid in this namespace\n"
msgstr ""

#: misc-utils/uuidgen.c:35
msgid " -N, --name name     generate hash-based uuid from this name\n"
msgstr ""

#: misc-utils/uuidgen.c:36
#, fuzzy
msgid " -m, --md5           generate md5 hash\n"
msgstr " -a, --all            打印所有设备\n"

#: misc-utils/uuidgen.c:37
#, fuzzy
msgid " -s, --sha1          generate sha1 hash\n"
msgstr " -s, --shared             获取共享锁\n"

#: misc-utils/uuidgen.c:38
#, fuzzy
msgid " -x, --hex           interpret name as hex string\n"
msgstr " -i, --invert           反转搜索的匹配\n"

#: misc-utils/uuidparse.c:76
#, fuzzy
msgid "unique identifier"
msgstr "惟一存储标识符"

#: misc-utils/uuidparse.c:77
#, fuzzy
msgid "variant name"
msgstr "分区名"

#: misc-utils/uuidparse.c:78
#, fuzzy
msgid "type name"
msgstr "新名称"

#: misc-utils/uuidparse.c:79
msgid "timestamp"
msgstr ""

#: misc-utils/uuidparse.c:97
#, fuzzy, c-format
msgid " %s [options] <uuid ...>\n"
msgstr " %s [选项] <文件>...\n"

#: misc-utils/uuidparse.c:100
#, fuzzy
msgid " -J, --json             use JSON output format"
msgstr " -J, --json              使用 JSON 输出格式\n"

#: misc-utils/uuidparse.c:101
#, fuzzy
msgid " -n, --noheadings       don't print headings"
msgstr " -n, --noheadings       不打印标题\n"

#: misc-utils/uuidparse.c:102
#, fuzzy
msgid " -o, --output <list>    COLUMNS to display (see below)"
msgstr " -o, --output <列表>    要显示的列\n"

#: misc-utils/uuidparse.c:103
#, fuzzy
msgid " -r, --raw              use the raw output format"
msgstr " -r, --raw              使用原生输出格式\n"

#: misc-utils/uuidparse.c:172 misc-utils/uuidparse.c:191
#: misc-utils/uuidparse.c:222
#, fuzzy
msgid "invalid"
msgstr "无效 id"

#: misc-utils/uuidparse.c:186
msgid "other"
msgstr ""

#: misc-utils/uuidparse.c:197
msgid "nil"
msgstr ""

#: misc-utils/uuidparse.c:202
msgid "time-based"
msgstr ""

#: misc-utils/uuidparse.c:208
msgid "name-based"
msgstr ""

#: misc-utils/uuidparse.c:211
msgid "random"
msgstr ""

#: misc-utils/uuidparse.c:214
msgid "sha1-based"
msgstr ""

#: misc-utils/uuidparse.c:267 misc-utils/wipefs.c:170 sys-utils/lscpu.c:1722
#: sys-utils/lsns.c:806 sys-utils/zramctl.c:496
msgid "failed to initialize output column"
msgstr "初始化输出列失败"

#: misc-utils/whereis.c:199
#, c-format
msgid " %s [options] [-BMS <dir>... -f] <name>\n"
msgstr " %s [选项] [-BMS <dir>... -f] <名称>\n"

#: misc-utils/whereis.c:202
msgid "Locate the binary, source, and manual-page files for a command.\n"
msgstr "定位某个命令的二进制文件、源码和帮助页文件。\n"

#: misc-utils/whereis.c:205
msgid " -b         search only for binaries\n"
msgstr " -b         只搜索二进制文件\n"

#: misc-utils/whereis.c:206
msgid " -B <dirs>  define binaries lookup path\n"
msgstr " -B <目录>  定义二进制文件查找路径\n"

#: misc-utils/whereis.c:207
msgid " -m         search only for manuals and infos\n"
msgstr " -m         只搜索手册和信息\n"

#: misc-utils/whereis.c:208
msgid " -M <dirs>  define man and info lookup path\n"
msgstr " -M <目录>  定义 man 和 info 查找路径\n"

#: misc-utils/whereis.c:209
msgid " -s         search only for sources\n"
msgstr " -s         只搜索源代码\n"

#: misc-utils/whereis.c:210
msgid " -S <dirs>  define sources lookup path\n"
msgstr " -S <目录>  定义源代码查找路径\n"

#: misc-utils/whereis.c:211
msgid " -f         terminate <dirs> argument list\n"
msgstr " -f         终止 <目录> 参数列表\n"

#: misc-utils/whereis.c:212
msgid " -u         search for unusual entries\n"
msgstr " -u         搜索不常见记录\n"

#: misc-utils/whereis.c:213
msgid " -l         output effective lookup paths\n"
msgstr " -l         输出有效查找路径\n"

#: misc-utils/whereis.c:648
msgid "option -f is missing"
msgstr "缺少 -f 选项"

#: misc-utils/wipefs.c:103
#, fuzzy
msgid "partition/filesystem UUID"
msgstr "文件系统 UUID"

#: misc-utils/wipefs.c:105
msgid "magic string length"
msgstr ""

#: misc-utils/wipefs.c:106
msgid "superblok type"
msgstr ""

#: misc-utils/wipefs.c:107
#, fuzzy
msgid "magic string offset"
msgstr "inode 偏移有误"

#: misc-utils/wipefs.c:108
#, fuzzy
msgid "type description"
msgstr "标志描述"

#: misc-utils/wipefs.c:109
#, fuzzy
msgid "block device name"
msgstr "块设备 "

#: misc-utils/wipefs.c:318
#, fuzzy
msgid "partition-table"
msgstr "分区表"

#: misc-utils/wipefs.c:406
#, c-format
msgid "error: %s: probing initialization failed"
msgstr "错误：%s：探测初始化失败"

#: misc-utils/wipefs.c:457
#, c-format
msgid "%s: failed to erase %s magic string at offset 0x%08jx"
msgstr "%1$s：擦除位于偏移 0x%3$08jx 处的魔数字符串 %2$s 失败"

#: misc-utils/wipefs.c:463
#, c-format
msgid "%s: %zd byte was erased at offset 0x%08jx (%s): "
msgid_plural "%s: %zd bytes were erased at offset 0x%08jx (%s): "
msgstr[0] "%s：%zd 个字节已擦除，位置偏移为 0x%08jx (%s)："

#: misc-utils/wipefs.c:492
#, c-format
msgid "%s: failed to create a signature backup"
msgstr "%s：创建签名备份失败"

#: misc-utils/wipefs.c:505
#, c-format
msgid "%s: calling ioctl to re-read partition table: %m\n"
msgstr "%s：将调用 ioctl 来重新读分区表：%m\n"

#: misc-utils/wipefs.c:528
msgid "failed to create a signature backup, $HOME undefined"
msgstr "创建签名备份失败，未定义 $HOME"

#: misc-utils/wipefs.c:546
#, c-format
msgid "%s: ignoring nested \"%s\" partition table on non-whole disk device"
msgstr "%s：忽略 非整盘 设备上的嵌套分区表“%s”"

#: misc-utils/wipefs.c:575
#, c-format
msgid "%s: offset 0x%jx not found"
msgstr "%s：找不到偏移 0x%jx"

#: misc-utils/wipefs.c:580
msgid "Use the --force option to force erase."
msgstr "使用 --force 选项强制擦除。"

#: misc-utils/wipefs.c:605
#, fuzzy
msgid "Wipe signatures from a device."
msgstr "从设备擦除签名。\n"

#: misc-utils/wipefs.c:608
#, fuzzy
msgid " -a, --all           wipe all magic strings (BE CAREFUL!)"
msgstr " -a, --all            打印所有设备\n"

#: misc-utils/wipefs.c:609
#, fuzzy
msgid " -b, --backup        create a signature backup in $HOME"
msgstr "创建签名备份失败，未定义 $HOME"

#: misc-utils/wipefs.c:610
#, fuzzy
msgid " -f, --force         force erasure"
msgstr " -f, --force      强制检查\n"

#: misc-utils/wipefs.c:611
#, fuzzy
msgid " -i, --noheadings    don't print headings"
msgstr " -n, --noheadings     不打印标题\n"

#: misc-utils/wipefs.c:612
#, fuzzy
msgid " -J, --json          use JSON output format"
msgstr " -J, --json           使用 JSON 输出格式\n"

#: misc-utils/wipefs.c:613
#, fuzzy
msgid " -n, --no-act        do everything except the actual write() call"
msgstr "     --no-act             操作但不实际写入日志\n"

#: misc-utils/wipefs.c:614
#, fuzzy
msgid " -o, --offset <num>  offset to erase, in bytes"
msgstr " -o, --offset <数字>  范围操作的偏移量(字节数)\n"

#: misc-utils/wipefs.c:615
msgid " -O, --output <list> COLUMNS to display (see below)"
msgstr ""

#: misc-utils/wipefs.c:616
#, fuzzy
msgid " -p, --parsable      print out in parsable instead of printable format"
msgstr " -p, --parse[=<列表>]    打印可解析格式\n"

#: misc-utils/wipefs.c:617
#, fuzzy
msgid " -q, --quiet         suppress output messages"
msgstr " -q, --quiet               禁止输出额外信息\n"

#: misc-utils/wipefs.c:618
#, fuzzy
msgid " -t, --types <list>  limit the set of filesystem, RAIDs or partition tables"
msgstr " -t, --types <列表>     根据文件系统类型限制文件系统集合\n"

#: misc-utils/wipefs.c:724
msgid "The --backup option is meaningless in this context"
msgstr "--backup 在此环境中无意义"

#: schedutils/chrt.c:135
msgid "Show or change the real-time scheduling attributes of a process.\n"
msgstr "显示或更改某个进程的实时调度属性。\n"

#: schedutils/chrt.c:137
msgid ""
"Set policy:\n"
" chrt [options] <priority> <command> [<arg>...]\n"
" chrt [options] --pid <priority> <pid>\n"
msgstr ""
"设置策略：\n"
" chrt [选项] <优先级> <命令> [<参数>...]\n"
" chrt [选项] --pid <优先级> <pid>\n"

#: schedutils/chrt.c:141
msgid ""
"Get policy:\n"
" chrt [options] -p <pid>\n"
msgstr ""
"获取策略\n"
" chrt [选项] -p <pid>\n"

#: schedutils/chrt.c:145
msgid "Policy options:\n"
msgstr "策略选项：\n"

#: schedutils/chrt.c:146
msgid " -b, --batch          set policy to SCHED_BATCH\n"
msgstr " -b, --batch          将策略设置为 SCHED_BATCH\n"

#: schedutils/chrt.c:147
msgid " -d, --deadline       set policy to SCHED_DEADLINE\n"
msgstr " -d, --deadline       将策略设置为 SCHED_DEADLINE\n"

#: schedutils/chrt.c:148
msgid " -f, --fifo           set policy to SCHED_FIFO\n"
msgstr " -f, --fifo           将策略设置为 SCHED_FIFO\n"

#: schedutils/chrt.c:149
msgid " -i, --idle           set policy to SCHED_IDLE\n"
msgstr " -i, --idle           将策略设置为 SCHED_IDLE\n"

#: schedutils/chrt.c:150
msgid " -o, --other          set policy to SCHED_OTHER\n"
msgstr " -o, --other          将策略设置为 SCHED_OTHER\n"

#: schedutils/chrt.c:151
msgid " -r, --rr             set policy to SCHED_RR (default)\n"
msgstr " -r, --rr             将策略设置为 SCHED_RR (默认)\n"

#: schedutils/chrt.c:154
msgid "Scheduling options:\n"
msgstr "调度选项：\n"

#: schedutils/chrt.c:155
msgid " -R, --reset-on-fork       set SCHED_RESET_ON_FORK for FIFO or RR\n"
msgstr " -R, --reset-on-fork       为 FIFO 或 RR 设置 SCHED_RESET_ON_FORK\n"

#: schedutils/chrt.c:156
msgid " -T, --sched-runtime <ns>  runtime parameter for DEADLINE\n"
msgstr " -T, --sched-runtime <ns>  DEADLINE 的运行时参数\n"

#: schedutils/chrt.c:157
msgid " -P, --sched-period <ns>   period parameter for DEADLINE\n"
msgstr " -P, --sched-period <ns>  DEADLINE 的周期参数\n"

#: schedutils/chrt.c:158
msgid " -D, --sched-deadline <ns> deadline parameter for DEADLINE\n"
msgstr " -D, --sched-deadline <ns> DEADLINE 的截止时间参数\n"

#: schedutils/chrt.c:161
msgid "Other options:\n"
msgstr "其他选项：\n"

#: schedutils/chrt.c:162
msgid " -a, --all-tasks      operate on all the tasks (threads) for a given pid\n"
msgstr " -a, --all-tasks      对指定 pid 的所有任务(线程) 操作\n"

#: schedutils/chrt.c:163
msgid " -m, --max            show min and max valid priorities\n"
msgstr " -m, --max            显示最小和最大有效优先级\n"

#: schedutils/chrt.c:164
msgid " -p, --pid            operate on existing given pid\n"
msgstr " -p, --pid            对指定且存在的 pid 操作\n"

#: schedutils/chrt.c:165
msgid " -v, --verbose        display status information\n"
msgstr " -v, --verbose        显示状态信息\n"

#: schedutils/chrt.c:231 schedutils/chrt.c:253
#, c-format
msgid "failed to get pid %d's policy"
msgstr "无法获得 pid %d 的策略"

#: schedutils/chrt.c:256
#, c-format
msgid "failed to get pid %d's attributes"
msgstr "获取 pid %d 的属性失败"

#: schedutils/chrt.c:266
#, c-format
msgid "pid %d's new scheduling policy: %s"
msgstr "pid “%d” 的新调度策略：%s"

#: schedutils/chrt.c:268
#, c-format
msgid "pid %d's current scheduling policy: %s"
msgstr "pid %d 当前的调度策略︰ %s"

#: schedutils/chrt.c:275
#, c-format
msgid "pid %d's new scheduling priority: %d\n"
msgstr "pid %d 的新调度策略：%d\n"

#: schedutils/chrt.c:277
#, c-format
msgid "pid %d's current scheduling priority: %d\n"
msgstr "pid %d 的当前调度优先级：%d\n"

#: schedutils/chrt.c:282
#, c-format
msgid "pid %d's new runtime/deadline/period parameters: %ju/%ju/%ju\n"
msgstr "pid %d 新的运行时/截止时间/周期参数︰ %ju/%ju/%ju\n"

#: schedutils/chrt.c:285
#, c-format
msgid "pid %d's current runtime/deadline/period parameters: %ju/%ju/%ju\n"
msgstr "pid %d 当前的运行时/截止时间/周期参数︰ %ju/%ju/%ju\n"

#: schedutils/chrt.c:299 schedutils/chrt.c:395
msgid "cannot obtain the list of tasks"
msgstr "无法获取任务列表"

#: schedutils/chrt.c:333
#, c-format
msgid "%s min/max priority\t: %d/%d\n"
msgstr "%s 最小/最大优先级\t: %d/%d\n"

#: schedutils/chrt.c:336
#, c-format
msgid "%s not supported?\n"
msgstr "%s 不支持？ \n"

#: schedutils/chrt.c:399
#, c-format
msgid "failed to set tid %d's policy"
msgstr "设置 tid %d 策略失败"

#: schedutils/chrt.c:404
#, c-format
msgid "failed to set pid %d's policy"
msgstr "设置 pid %d 的策略失败"

#: schedutils/chrt.c:484
msgid "invalid runtime argument"
msgstr "无效的运行时参数"

#: schedutils/chrt.c:487
msgid "invalid period argument"
msgstr "无效的周期参数"

#: schedutils/chrt.c:490
msgid "invalid deadline argument"
msgstr "无效的截止时间参数"

#: schedutils/chrt.c:515
msgid "invalid priority argument"
msgstr "无效的 优先级 参数"

#: schedutils/chrt.c:519
msgid "--reset-on-fork option is supported for SCHED_FIFO and SCHED_RR policies only"
msgstr "--reset-on-fork 选项只支持 SCHED_FIFO and SCHED_RR 策略"

#: schedutils/chrt.c:524
msgid "--sched-{runtime,deadline,period} options are supported for SCHED_DEADLINE only"
msgstr "--sched-{runtime,deadline,period} 选项只支持 SCHED_DEADLINE"

#: schedutils/chrt.c:539
msgid "SCHED_DEADLINE is unsupported"
msgstr "不支持 SCHED_DEADLINE"

#: schedutils/chrt.c:546
#, c-format
msgid "unsupported priority value for the policy: %d: see --max for valid range"
msgstr "不支持此策略的优先级值：%d：查看 --max 了解有效范围"

#: schedutils/ionice.c:76
msgid "ioprio_get failed"
msgstr "ioprio_get 失败"

#: schedutils/ionice.c:85
#, c-format
msgid "%s: prio %lu\n"
msgstr "%s：优先级 %lu\n"

#: schedutils/ionice.c:98
msgid "ioprio_set failed"
msgstr "ioprio_set 失败"

#: schedutils/ionice.c:105
#, c-format
msgid ""
" %1$s [options] -p <pid>...\n"
" %1$s [options] -P <pgid>...\n"
" %1$s [options] -u <uid>...\n"
" %1$s [options] <command>\n"
msgstr ""
" %1$s [选项] -p <pid>...\n"
" %1$s [选项] -P <pgid>...\n"
" %1$s [选项] -u <uid>...\n"
" %1$s [选项] <命令>\n"

#: schedutils/ionice.c:111
msgid "Show or change the I/O-scheduling class and priority of a process.\n"
msgstr "设置或更改进程的 IO 调度类别和优先级。\n"

#: schedutils/ionice.c:114
msgid ""
" -c, --class <class>    name or number of scheduling class,\n"
"                          0: none, 1: realtime, 2: best-effort, 3: idle\n"
msgstr ""
" -c, --class <类别>    调度类别的名称或数值\n"
"                          0: 无, 1: 实时, 2: 尽力, 3: 空闲\n"

#: schedutils/ionice.c:116
msgid ""
" -n, --classdata <num>  priority (0..7) in the specified scheduling class,\n"
"                          only for the realtime and best-effort classes\n"
msgstr ""
" -n, --classdata <数字> 指定调度类别的优先级(0..7)，只针对\n"
"                          “实时”和“尽力”类别\n"

#: schedutils/ionice.c:118
msgid " -p, --pid <pid>...     act on these already running processes\n"
msgstr " -p, --pid <pid>...     对这些已运行的进程操作\n"

#: schedutils/ionice.c:119
msgid " -P, --pgid <pgrp>...   act on already running processes in these groups\n"
msgstr " -P, --pgid <pgrp>...   对这些组中已运行的进程操作\n"

#: schedutils/ionice.c:120
msgid " -t, --ignore           ignore failures\n"
msgstr " -t, --ignore           忽略失败\n"

#: schedutils/ionice.c:121
msgid " -u, --uid <uid>...     act on already running processes owned by these users\n"
msgstr " -u, --uid <uid>...     对属于这些用户的已运行进程操作\n"

#: schedutils/ionice.c:157
msgid "invalid class data argument"
msgstr "无效的类别数据参数"

#: schedutils/ionice.c:163
msgid "invalid class argument"
msgstr "无效的类别参数"

#: schedutils/ionice.c:168
#, c-format
msgid "unknown scheduling class: '%s'"
msgstr "未知的调度类别：“%s”"

#: schedutils/ionice.c:176 schedutils/ionice.c:184 schedutils/ionice.c:192
msgid "can handle only one of pid, pgid or uid at once"
msgstr "无法一次只处理一个 pid、pgid 或 uid"

#: schedutils/ionice.c:185
msgid "invalid PGID argument"
msgstr "无效的 PGID 参数"

#: schedutils/ionice.c:193
msgid "invalid UID argument"
msgstr "无效的 UID 参数"

#: schedutils/ionice.c:212
msgid "ignoring given class data for none class"
msgstr "将忽略为“无”类别指定的类别数据"

#: schedutils/ionice.c:220
msgid "ignoring given class data for idle class"
msgstr "将忽略为“空闲”类别指定的类别数据"

#: schedutils/ionice.c:225
#, c-format
msgid "unknown prio class %d"
msgstr "未知的优先级类别 %d"

#: schedutils/taskset.c:52
#, c-format
msgid ""
"Usage: %s [options] [mask | cpu-list] [pid|cmd [args...]]\n"
"\n"
msgstr ""
"用法：%s [选项] [掩码 | cpu列表] [pid|命令 [参数...]]\n"
"\n"

#: schedutils/taskset.c:56
msgid "Show or change the CPU affinity of a process.\n"
msgstr "显示或更改某个进程的 CPU 亲和力。\n"

#: schedutils/taskset.c:60
#, fuzzy, c-format
msgid ""
"Options:\n"
" -a, --all-tasks         operate on all the tasks (threads) for a given pid\n"
" -p, --pid               operate on existing given pid\n"
" -c, --cpu-list          display and specify cpus in list format\n"
msgstr ""
"选项：\n"
" -a, --all-tasks         在给定 pid 的所有任务(线程)上操作\n"
" -p, --pid               在存在的给定 pid 上操作\n"
" -c, --cpu-list          以列表格式显示和指定 CPU\n"
" -h, --help              显示此帮助\n"
" -V, --version           输出版本信息\n"
"\n"

#: schedutils/taskset.c:69
#, c-format
msgid ""
"The default behavior is to run a new command:\n"
"    %1$s 03 sshd -b 1024\n"
"You can retrieve the mask of an existing task:\n"
"    %1$s -p 700\n"
"Or set it:\n"
"    %1$s -p 03 700\n"
"List format uses a comma-separated list instead of a mask:\n"
"    %1$s -pc 0,3,7-11 700\n"
"Ranges in list format can take a stride argument:\n"
"    e.g. 0-31:2 is equivalent to mask 0x55555555\n"
msgstr ""
"默认行为是运行一条新命令：\n"
"    %1$s 03 sshd -b 1024\n"
"您可以获取现有任务的掩码：\n"
"    %1$s -p 700\n"
"或设置掩码：\n"
"    %1$s -p 03 700\n"
"使用逗号分隔的列表格式而不是掩码：\n"
"    %1$s -pc 0,3,7-11 700\n"
"列表格式中的范围可以带一个跨度参数：\n"
"    例如 0-31:2 与掩码 0x55555555 等效\n"

#: schedutils/taskset.c:91
#, c-format
msgid "pid %d's new affinity list: %s\n"
msgstr "pid %d 的新亲和力列表：%s\n"

#: schedutils/taskset.c:92
#, c-format
msgid "pid %d's current affinity list: %s\n"
msgstr "pid %d 的当前亲和力列表：%s\n"

#: schedutils/taskset.c:95
#, c-format
msgid "pid %d's new affinity mask: %s\n"
msgstr "pid %d 的新亲和力掩码：%s\n"

#: schedutils/taskset.c:96
#, c-format
msgid "pid %d's current affinity mask: %s\n"
msgstr "pid %d 的当前亲和力掩码：%s\n"

#: schedutils/taskset.c:100
msgid "internal error: conversion from cpuset to string failed"
msgstr "内部错误：从 cpuset 转换到字符串失败"

#: schedutils/taskset.c:109
#, c-format
msgid "failed to set pid %d's affinity"
msgstr "设置 pid %d 的亲和力失败"

#: schedutils/taskset.c:110
#, c-format
msgid "failed to get pid %d's affinity"
msgstr "获取 pid %d 的亲和力失败"

#: schedutils/taskset.c:195 sys-utils/chcpu.c:292
msgid "cannot determine NR_CPUS; aborting"
msgstr "无法确定 NR_CPUS；将中止"

#: schedutils/taskset.c:204 schedutils/taskset.c:217 sys-utils/chcpu.c:298
msgid "cpuset_alloc failed"
msgstr "cpuset_alloc 失败"

#: schedutils/taskset.c:224 sys-utils/chcpu.c:232
#, c-format
msgid "failed to parse CPU list: %s"
msgstr "解析 CPU 列表失败：%s"

#: schedutils/taskset.c:227
#, c-format
msgid "failed to parse CPU mask: %s"
msgstr "解析 CPU 掩码失败：%s"

#: sys-utils/blkdiscard.c:69
#, c-format
msgid "%s: Zero-filled %<PRIu64> bytes from the offset %<PRIu64>\n"
msgstr "%s: 用零填充的 %<PRIu64> 个字节，始于偏移量 %<PRIu64>\n"

#: sys-utils/blkdiscard.c:74
#, c-format
msgid "%s: Discarded %<PRIu64> bytes from the offset %<PRIu64>\n"
msgstr "%1$s：已忽略从偏移 %3$<PRIu64> 位置开始的 %2$<PRIu64> 个字节\n"

#: sys-utils/blkdiscard.c:88
msgid "Discard the content of sectors on a device.\n"
msgstr "丢弃一个设备上的扇区内容。\n"

#: sys-utils/blkdiscard.c:91
msgid " -o, --offset <num>  offset in bytes to discard from\n"
msgstr " -o, --offset <数值> 要丢弃的起始位置(字节)\n"

#: sys-utils/blkdiscard.c:92
msgid " -l, --length <num>  length of bytes to discard from the offset\n"
msgstr " -l, --length <数值> 从起始处起要丢弃的长度(字节数)\n"

#: sys-utils/blkdiscard.c:93
msgid " -p, --step <num>    size of the discard iterations within the offset\n"
msgstr " -p, --step <数值>   在偏移范围内丢弃迭代的尺寸\n"

#: sys-utils/blkdiscard.c:94
msgid " -s, --secure        perform secure discard\n"
msgstr " -s, --secure        执行安全丢弃\n"

#: sys-utils/blkdiscard.c:95
msgid " -z, --zeroout       zero-fill rather than discard\n"
msgstr " -z, --zeroout       用 零填充而非丢弃\n"

#: sys-utils/blkdiscard.c:96
msgid " -v, --verbose       print aligned length and offset\n"
msgstr " -v, --verbose       打印对齐的长度和偏移\n"

#: sys-utils/blkdiscard.c:150 sys-utils/fstrim.c:314 sys-utils/losetup.c:691
#: text-utils/hexdump.c:124
msgid "failed to parse offset"
msgstr "解析偏移失败"

#: sys-utils/blkdiscard.c:154
msgid "failed to parse step"
msgstr "解析步长失败"

#: sys-utils/blkdiscard.c:176 sys-utils/blkzone.c:398 sys-utils/fallocate.c:373
#: sys-utils/fsfreeze.c:111 sys-utils/fstrim.c:336
msgid "unexpected number of arguments"
msgstr "参数数量异常"

#: sys-utils/blkdiscard.c:190
#, c-format
msgid "%s: BLKGETSIZE64 ioctl failed"
msgstr "%s：BLKGETSIZE64 ioctl 失败"

#: sys-utils/blkdiscard.c:192 sys-utils/blkzone.c:107
#, c-format
msgid "%s: BLKSSZGET ioctl failed"
msgstr "%s：BLKSSZGET ioctl 失败"

#: sys-utils/blkdiscard.c:196
#, c-format
msgid "%s: offset %<PRIu64> is not aligned to sector size %i"
msgstr "%s: 偏移量 %<PRIu64> 未与扇区大小 %i 对齐"

#: sys-utils/blkdiscard.c:201 sys-utils/blkzone.c:173 sys-utils/blkzone.c:261
#, c-format
msgid "%s: offset is greater than device size"
msgstr "%s：偏移量超过设备大小"

#: sys-utils/blkdiscard.c:210
#, c-format
msgid "%s: length %<PRIu64> is not aligned to sector size %i"
msgstr "%s: 长度 %<PRIu64> 未与扇区大小 %i 对齐"

#: sys-utils/blkdiscard.c:223
#, c-format
msgid "%s: BLKZEROOUT ioctl failed"
msgstr "%s: BLKZEROOUT ioctl 失败"

#: sys-utils/blkdiscard.c:227
#, c-format
msgid "%s: BLKSECDISCARD ioctl failed"
msgstr "%s：BLKSECDISCARD ioctl 失败"

#: sys-utils/blkdiscard.c:231
#, c-format
msgid "%s: BLKDISCARD ioctl failed"
msgstr "%s：BLKDISCARD ioctl 失败"

#: sys-utils/blkzone.c:73
#, fuzzy
msgid "Report zone information about the given device"
msgstr "列出块设备的信息。\n"

#: sys-utils/blkzone.c:74
msgid "Reset a range of zones."
msgstr ""

#: sys-utils/blkzone.c:104
#, fuzzy, c-format
msgid "%s: blkdev_get_sectors ioctl failed"
msgstr "%s︰ 设置直接 io 失败"

#: sys-utils/blkzone.c:177 sys-utils/blkzone.c:251
#, fuzzy, c-format
msgid "%s: unable to determine zone size"
msgstr "%s：无法写 zone map"

#: sys-utils/blkzone.c:195
#, fuzzy, c-format
msgid "%s: BLKREPORTZONE ioctl failed"
msgstr "%s：BLKGETSIZE64 ioctl 失败"

#: sys-utils/blkzone.c:198
#, c-format
msgid "Found %d zones from 0x%<PRIx64>\n"
msgstr ""

#: sys-utils/blkzone.c:219
#, c-format
msgid "  start: 0x%09<PRIx64>, len 0x%06<PRIx64>, wptr 0x%06<PRIx64> reset:%u non-seq:%u, zcond:%2u(%s) [type: %u(%s)]\n"
msgstr ""

#: sys-utils/blkzone.c:256
#, fuzzy, c-format
msgid "%s: offset %<PRIu64> is not aligned to zone size %lu"
msgstr "%s: 偏移量 %<PRIu64> 未与扇区大小 %i 对齐"

#: sys-utils/blkzone.c:275
#, fuzzy, c-format
msgid "%s: number of sectors %<PRIu64> is not aligned to zone size %lu"
msgstr "%s: 偏移量 %<PRIu64> 未与扇区大小 %i 对齐"

#: sys-utils/blkzone.c:283
#, fuzzy, c-format
msgid "%s: BLKRESETZONE ioctl failed"
msgstr "%s：BLKSSZGET ioctl 失败"

#: sys-utils/blkzone.c:285
#, fuzzy, c-format
msgid "%s: successfully reset in range from %<PRIu64>, to %<PRIu64>"
msgstr "分区表长度已从 %<PRIu32> 改为 %<PRIu64>。"

#: sys-utils/blkzone.c:299
#, fuzzy, c-format
msgid " %s <command> [options] <device>\n"
msgstr " %s [选项] <设备>\n"

#: sys-utils/blkzone.c:302
msgid "Run zone command on the given block device.\n"
msgstr ""

#: sys-utils/blkzone.c:309
#, fuzzy
msgid " -o, --offset <sector>  start sector of zone to act (in 512-byte sectors)\n"
msgstr " -o, --offset <数字>  范围操作的偏移量(字节数)\n"

#: sys-utils/blkzone.c:310
msgid " -l, --length <sectors> maximum sectors to act (in 512-byte sectors)\n"
msgstr ""

#: sys-utils/blkzone.c:311
#, fuzzy
msgid " -c, --count <number>   maximum number of zones\n"
msgstr " -t, --streams <数字>      压缩流数量\n"

#: sys-utils/blkzone.c:312
#, fuzzy
msgid " -v, --verbose          display more details\n"
msgstr "     --verbose          打印更多细节\n"

#: sys-utils/blkzone.c:354
#, fuzzy, c-format
msgid "%s is not valid command name"
msgstr "%s 不是一个有效的块设备"

#: sys-utils/blkzone.c:369
#, fuzzy
msgid "failed to parse number of zones"
msgstr "解析行数失败"

#: sys-utils/blkzone.c:373
#, fuzzy
msgid "failed to parse number of sectors"
msgstr "解析行数失败"

#: sys-utils/blkzone.c:377
#, fuzzy
msgid "failed to parse zone offset"
msgstr "解析偏移失败"

#: sys-utils/blkzone.c:391 sys-utils/setsid.c:92
#, fuzzy
msgid "no command specified"
msgstr "没有指定命令"

#: sys-utils/chcpu.c:87 sys-utils/chcpu.c:179
#, c-format
msgid "CPU %u does not exist"
msgstr "CPU %u 不存在"

#: sys-utils/chcpu.c:92
#, c-format
msgid "CPU %u is not hot pluggable"
msgstr "CPU %u 不能进行热插拔"

#: sys-utils/chcpu.c:98
#, c-format
msgid "CPU %u is already enabled\n"
msgstr "CPU %u 已经启用\n"

#: sys-utils/chcpu.c:102
#, c-format
msgid "CPU %u is already disabled\n"
msgstr "CPU %u 已经禁用\n"

#: sys-utils/chcpu.c:110
#, c-format
msgid "CPU %u enable failed (CPU is deconfigured)"
msgstr "CPU %u 启用失败(CPU 已取消配置)"

#: sys-utils/chcpu.c:113
#, c-format
msgid "CPU %u enable failed"
msgstr "CPU %u 启用失败"

#: sys-utils/chcpu.c:116
#, c-format
msgid "CPU %u enabled\n"
msgstr "CPU %u 已启用\n"

#: sys-utils/chcpu.c:119
#, c-format
msgid "CPU %u disable failed (last enabled CPU)"
msgstr "CPU %u 禁用失败 (最后启用的 CPU)"

#: sys-utils/chcpu.c:125
#, c-format
msgid "CPU %u disable failed"
msgstr "CPU %u 禁用失败"

#: sys-utils/chcpu.c:128
#, c-format
msgid "CPU %u disabled\n"
msgstr "CPU %u 已禁用\n"

#: sys-utils/chcpu.c:141
msgid "This system does not support rescanning of CPUs"
msgstr "该系统不支持重新扫描 CPU"

#: sys-utils/chcpu.c:143
msgid "Failed to trigger rescan of CPUs"
msgstr "触发 CPU 重新扫描失败"

#: sys-utils/chcpu.c:144
#, c-format
msgid "Triggered rescan of CPUs\n"
msgstr "已触发 CPU 重新扫描\n"

#: sys-utils/chcpu.c:151
msgid "This system does not support setting the dispatching mode of CPUs"
msgstr "此系统不支持设置 CPU 分派模式(dispatching mode)"

#: sys-utils/chcpu.c:155
msgid "Failed to set horizontal dispatch mode"
msgstr "设置水平分派模式失败"

#: sys-utils/chcpu.c:156
#, c-format
msgid "Successfully set horizontal dispatching mode\n"
msgstr "成功设置了水平分派模式\n"

#: sys-utils/chcpu.c:159
msgid "Failed to set vertical dispatch mode"
msgstr "设置竖直分派模式失败"

#: sys-utils/chcpu.c:160
#, c-format
msgid "Successfully set vertical dispatching mode\n"
msgstr "成功设置了竖直分派模式\n"

#: sys-utils/chcpu.c:184
#, c-format
msgid "CPU %u is not configurable"
msgstr "CPU %u 是不可配置的"

#: sys-utils/chcpu.c:190
#, c-format
msgid "CPU %u is already configured\n"
msgstr "CPU %u 是已经配置过的\n"

#: sys-utils/chcpu.c:194
#, c-format
msgid "CPU %u is already deconfigured\n"
msgstr "CPU %u 是已经取消配置的\n"

#: sys-utils/chcpu.c:199
#, c-format
msgid "CPU %u deconfigure failed (CPU is enabled)"
msgstr "CPU %u 取消配置失败(CPU 已启用)"

#: sys-utils/chcpu.c:206
#, c-format
msgid "CPU %u configure failed"
msgstr "CPU %u 配置失败"

#: sys-utils/chcpu.c:209
#, c-format
msgid "CPU %u configured\n"
msgstr "CPU %u 已配置\n"

#: sys-utils/chcpu.c:213
#, c-format
msgid "CPU %u deconfigure failed"
msgstr "CPU %u 取消配置失败"

#: sys-utils/chcpu.c:216
#, c-format
msgid "CPU %u deconfigured\n"
msgstr "CPU %u 已取消配置\n"

#: sys-utils/chcpu.c:231
#, c-format
msgid "invalid CPU number in CPU list: %s"
msgstr "CPU 列表中的 CPU 数量无效：%s"

#: sys-utils/chcpu.c:239 text-utils/col.c:131
#, c-format
msgid ""
"\n"
"Usage:\n"
" %s [options]\n"
msgstr ""
"\n"
"用法：\n"
" %s [选项]\n"

#: sys-utils/chcpu.c:243
msgid "Configure CPUs in a multi-processor system.\n"
msgstr "配置多处理器系统中的 CPU。\n"

#: sys-utils/chcpu.c:247
#, fuzzy
msgid ""
" -e, --enable <cpu-list>       enable cpus\n"
" -d, --disable <cpu-list>      disable cpus\n"
" -c, --configure <cpu-list>    configure cpus\n"
" -g, --deconfigure <cpu-list>  deconfigure cpus\n"
" -p, --dispatch <mode>         set dispatching mode\n"
" -r, --rescan                  trigger rescan of cpus\n"
msgstr ""
"\n"
"选项：\n"
"  -h, --help                    打印此帮助\n"
"  -e, --enable <cpu列表>        启用 cpu\n"
"  -d, --disable <cpu列表>       禁用 cpu\n"
"  -c, --configure <cpu列表>     配置 cpu\n"
"  -g, --deconfigure <cpu列表>   取消配置 cpu\n"
"  -p, --dispatch <模式>         设置分派模式\n"
"  -r, --rescan                  触发重新扫描 cpu\n"
"  -V, --version                 输出版本信息并退出\n"

#: sys-utils/chcpu.c:329
#, c-format
msgid "unsupported argument: %s"
msgstr "不支持的参数：%s"

#: sys-utils/chmem.c:100
#, c-format
msgid "Memory Block %<PRIu64> (0x%016<PRIx64>-0x%016<PRIx64>)"
msgstr ""

#: sys-utils/chmem.c:124 sys-utils/chmem.c:197
#, fuzzy
msgid "Failed to parse index"
msgstr "解析 id 失败"

#: sys-utils/chmem.c:151
#, fuzzy, c-format
msgid "%s enable failed\n"
msgstr "CPU %u 启用失败"

#: sys-utils/chmem.c:153
#, fuzzy, c-format
msgid "%s disable failed\n"
msgstr "CPU %u 禁用失败"

#: sys-utils/chmem.c:156 sys-utils/chmem.c:243
#, fuzzy, c-format
msgid "%s enabled\n"
msgstr "CPU %u 已启用\n"

#: sys-utils/chmem.c:158 sys-utils/chmem.c:245
#, fuzzy, c-format
msgid "%s disabled\n"
msgstr "CPU %u 已禁用\n"

#: sys-utils/chmem.c:170
#, c-format
msgid "Could only enable %s of memory"
msgstr ""

#: sys-utils/chmem.c:172
#, c-format
msgid "Could only disable %s of memory"
msgstr ""

#: sys-utils/chmem.c:206
#, fuzzy, c-format
msgid "%s already enabled\n"
msgstr "CPU %u 已经启用\n"

#: sys-utils/chmem.c:208
#, fuzzy, c-format
msgid "%s already disabled\n"
msgstr "CPU %u 已经禁用\n"

#: sys-utils/chmem.c:219
#, fuzzy, c-format
msgid "%s enable failed: Zone mismatch"
msgstr "CPU %u 启用失败"

#: sys-utils/chmem.c:223
#, fuzzy, c-format
msgid "%s disable failed: Zone mismatch"
msgstr "CPU %u 禁用失败"

#: sys-utils/chmem.c:238
#, fuzzy, c-format
msgid "%s enable failed"
msgstr "CPU %u 启用失败"

#: sys-utils/chmem.c:240
#, fuzzy, c-format
msgid "%s disable failed"
msgstr "CPU %u 禁用失败"

#: sys-utils/chmem.c:266 sys-utils/lsmem.c:476 sys-utils/lsmem.c:480
#, fuzzy, c-format
msgid "Failed to read %s"
msgstr "读 速度 失败"

#: sys-utils/chmem.c:274
#, fuzzy
msgid "Failed to parse block number"
msgstr "解析数字失败"

#: sys-utils/chmem.c:279
#, fuzzy
msgid "Failed to parse size"
msgstr "解析大小失败。"

#: sys-utils/chmem.c:283
#, c-format
msgid "Size must be aligned to memory block size (%s)"
msgstr ""

#: sys-utils/chmem.c:292
#, fuzzy
msgid "Failed to parse start"
msgstr "解析 起点 失败"

#: sys-utils/chmem.c:293
#, fuzzy
msgid "Failed to parse end"
msgstr "解析 终点 失败"

#: sys-utils/chmem.c:297
#, fuzzy, c-format
msgid "Invalid start address format: %s"
msgstr "无效的 起点 参数"

#: sys-utils/chmem.c:299
#, fuzzy, c-format
msgid "Invalid end address format: %s"
msgstr "无效的信号名或数字：%s"

#: sys-utils/chmem.c:300
#, fuzzy
msgid "Failed to parse start address"
msgstr "解析 起点 失败"

#: sys-utils/chmem.c:301
#, fuzzy
msgid "Failed to parse end address"
msgstr "解析 终点 失败"

#: sys-utils/chmem.c:304
#, c-format
msgid "Start address and (end address + 1) must be aligned to memory block size (%s)"
msgstr ""

#: sys-utils/chmem.c:318
#, fuzzy, c-format
msgid "Invalid parameter: %s"
msgstr "无效参数：%s"

#: sys-utils/chmem.c:325
#, fuzzy, c-format
msgid "Invalid range: %s"
msgstr "无效参数：%s"

#: sys-utils/chmem.c:334
#, fuzzy, c-format
msgid " %s [options] [SIZE|RANGE|BLOCKRANGE]\n"
msgstr " %s [选项] [y | n]\n"

#: sys-utils/chmem.c:337
msgid "Set a particular size or range of memory online or offline.\n"
msgstr ""

#: sys-utils/chmem.c:340
#, fuzzy
msgid " -e, --enable       enable memory\n"
msgstr " -v, --verbose    详尽方式\n"

#: sys-utils/chmem.c:341
#, fuzzy
msgid " -d, --disable      disable memory\n"
msgstr " -v, --verbose    详尽方式\n"

#: sys-utils/chmem.c:342
#, fuzzy
msgid " -b, --blocks       use memory blocks\n"
msgstr " -v, --verbose    详尽方式\n"

#: sys-utils/chmem.c:343
msgid " -z, --zone <name>  select memory zone (see below)\n"
msgstr ""

#: sys-utils/chmem.c:344
#, fuzzy
msgid " -v, --verbose      verbose output\n"
msgstr " -v, --verbose    详尽方式\n"

#: sys-utils/chmem.c:347
#, fuzzy
msgid ""
"\n"
"Supported zones:\n"
msgstr ""
"\n"
"支持的日志设施：\n"

#: sys-utils/chmem.c:429
msgid "zone ignored, no valid_zones sysfs attribute present"
msgstr ""

#: sys-utils/chmem.c:434
#, fuzzy, c-format
msgid "unknown memory zone: %s"
msgstr "月份名未知：%s"

#: sys-utils/ctrlaltdel.c:28
#, c-format
msgid " %s hard|soft\n"
msgstr " %s hard|soft\n"

#: sys-utils/ctrlaltdel.c:31
#, c-format
msgid "Set the function of the Ctrl-Alt-Del combination.\n"
msgstr "设置 Ctrl-Alt-Del 组合键的功能。\n"

#: sys-utils/ctrlaltdel.c:51
msgid "implicit"
msgstr "隐含"

#: sys-utils/ctrlaltdel.c:52
#, c-format
msgid "unexpected value in %s: %ju"
msgstr "%s 有异常值：%ju"

#: sys-utils/ctrlaltdel.c:63
msgid "You must be root to set the Ctrl-Alt-Del behavior"
msgstr "只有 root 用户才能设置 Ctrl-Alt-Del 行为"

#: sys-utils/ctrlaltdel.c:71 sys-utils/ipcrm.c:395 sys-utils/ipcrm.c:418
#, c-format
msgid "unknown argument: %s"
msgstr "未知参数：%s"

#: sys-utils/dmesg.c:109
msgid "system is unusable"
msgstr "系统无法使用"

#: sys-utils/dmesg.c:110
msgid "action must be taken immediately"
msgstr "操作必须立即执行"

#: sys-utils/dmesg.c:111
msgid "critical conditions"
msgstr "紧急条件"

#: sys-utils/dmesg.c:112
msgid "error conditions"
msgstr "错误条件"

#: sys-utils/dmesg.c:113
msgid "warning conditions"
msgstr "警告条件"

#: sys-utils/dmesg.c:114
msgid "normal but significant condition"
msgstr "正常但重要的条件"

#: sys-utils/dmesg.c:115
msgid "informational"
msgstr "信息"

#: sys-utils/dmesg.c:116
msgid "debug-level messages"
msgstr "调试级别的消息"

#: sys-utils/dmesg.c:130
msgid "kernel messages"
msgstr "内核消息"

#: sys-utils/dmesg.c:131
msgid "random user-level messages"
msgstr "随机的用户级消息"

#: sys-utils/dmesg.c:132
msgid "mail system"
msgstr "邮件系统"

#: sys-utils/dmesg.c:133
msgid "system daemons"
msgstr "系统守护进程"

#: sys-utils/dmesg.c:134
msgid "security/authorization messages"
msgstr "安全/认证消息"

#: sys-utils/dmesg.c:135
msgid "messages generated internally by syslogd"
msgstr "syslogd 内部生成的消息"

#: sys-utils/dmesg.c:136
msgid "line printer subsystem"
msgstr "行打印机子系统"

#: sys-utils/dmesg.c:137
msgid "network news subsystem"
msgstr "网络新闻子系统"

#: sys-utils/dmesg.c:138
msgid "UUCP subsystem"
msgstr "UUCP 子系统"

#: sys-utils/dmesg.c:139
msgid "clock daemon"
msgstr "时钟守护进程"

#: sys-utils/dmesg.c:140
msgid "security/authorization messages (private)"
msgstr "安全/认证消息(私有)"

#: sys-utils/dmesg.c:141
msgid "FTP daemon"
msgstr "ftp 守护进程"

#: sys-utils/dmesg.c:269
msgid "Display or control the kernel ring buffer.\n"
msgstr "显示或控制内核环形缓冲区。\n"

#: sys-utils/dmesg.c:272
msgid " -C, --clear                 clear the kernel ring buffer\n"
msgstr " -C, --clear                 清除内核环形缓冲区(ring butter)\n"

#: sys-utils/dmesg.c:273
msgid " -c, --read-clear            read and clear all messages\n"
msgstr " -c, --read-clear            读取并清除所有消息\n"

#: sys-utils/dmesg.c:274
msgid " -D, --console-off           disable printing messages to console\n"
msgstr " -D, --console-off           禁止向终端打印消息\n"

#: sys-utils/dmesg.c:275
msgid " -E, --console-on            enable printing messages to console\n"
msgstr " -E, --console-on            启用向终端打印消息\n"

#: sys-utils/dmesg.c:276
msgid " -F, --file <file>           use the file instead of the kernel log buffer\n"
msgstr " -F, --file <文件>           用 文件 代替内核日志缓冲区\n"

#: sys-utils/dmesg.c:277
msgid " -f, --facility <list>       restrict output to defined facilities\n"
msgstr " -f, --facility <列表>       将输出限制为定义的设施\n"

#: sys-utils/dmesg.c:278
msgid " -H, --human                 human readable output\n"
msgstr " -H, --human                 易读格式输出\n"

#: sys-utils/dmesg.c:279
msgid " -k, --kernel                display kernel messages\n"
msgstr " -k, --kernel                显示内核消息\n"

#: sys-utils/dmesg.c:280
msgid " -L, --color[=<when>]        colorize messages (auto, always or never)\n"
msgstr " -L, --color[=<时机>]        彩色显示消息(auto, always 或 never)\n"

#: sys-utils/dmesg.c:283
msgid " -l, --level <list>          restrict output to defined levels\n"
msgstr " -l, --level <列表>          限制输出级别\n"

#: sys-utils/dmesg.c:284
msgid " -n, --console-level <level> set level of messages printed to console\n"
msgstr " -n, --console-level <级别>  设置打印到终端的消息级别\n"

#: sys-utils/dmesg.c:285
msgid " -P, --nopager               do not pipe output into a pager\n"
msgstr " -P, --nopager               不将输出通过管道传递给分页程序\n"

#: sys-utils/dmesg.c:286
msgid " -p, --force-prefix          force timestamp output on each line of multi-line messages\n"
msgstr ""

#: sys-utils/dmesg.c:287
msgid " -r, --raw                   print the raw message buffer\n"
msgstr " -r, --raw                   打印原生消息缓冲区\n"

#: sys-utils/dmesg.c:288
msgid " -S, --syslog                force to use syslog(2) rather than /dev/kmsg\n"
msgstr " -S, --syslog                强制使用 syslog(2) 而非 /dev/kmsg\n"

#: sys-utils/dmesg.c:289
msgid " -s, --buffer-size <size>    buffer size to query the kernel ring buffer\n"
msgstr " -s, --buffer-size <大小>    查询内核环形缓冲区所用的缓冲区大小\n"

#: sys-utils/dmesg.c:290
msgid " -u, --userspace             display userspace messages\n"
msgstr " -u, --userspace             显示用户空间消息\n"

#: sys-utils/dmesg.c:291
msgid " -w, --follow                wait for new messages\n"
msgstr " -w, --follow                等待新消息\n"

#: sys-utils/dmesg.c:292
msgid " -x, --decode                decode facility and level to readable string\n"
msgstr " -x, --decode                将设施和级别解码为可读的字符串\n"

#: sys-utils/dmesg.c:293
msgid " -d, --show-delta            show time delta between printed messages\n"
msgstr " -d, --show-delta            显示打印消息之间的时间差\n"

#: sys-utils/dmesg.c:294
msgid " -e, --reltime               show local time and time delta in readable format\n"
msgstr " -e, --reltime               以易读格式显示本地时间和时间差\n"

#: sys-utils/dmesg.c:295
msgid " -T, --ctime                 show human-readable timestamp (may be inaccurate!)\n"
msgstr " -T, --ctime                 显示易读的时间戳(可能不准确！)\n"

#: sys-utils/dmesg.c:296
msgid " -t, --notime                don't show any timestamp with messages\n"
msgstr " -t, --notime                不显示任何消息的时间戳\n"

#: sys-utils/dmesg.c:297
msgid ""
"     --time-format <format>  show timestamp using the given format:\n"
"                               [delta|reltime|ctime|notime|iso]\n"
"Suspending/resume will make ctime and iso timestamps inaccurate.\n"
msgstr ""
"     --time-format <格式>    以指定格式显示时间戳：\n"
"                               [delta|reltime|ctime|notime|iso]\n"
"挂起/恢复会使 ctime 和 iso 时间戳不精确。\n"

#: sys-utils/dmesg.c:302
msgid ""
"\n"
"Supported log facilities:\n"
msgstr ""
"\n"
"支持的日志设施：\n"

#: sys-utils/dmesg.c:308
msgid ""
"\n"
"Supported log levels (priorities):\n"
msgstr ""
"\n"
"支持的日志级别(优先级)：\n"

#: sys-utils/dmesg.c:362
#, c-format
msgid "failed to parse level '%s'"
msgstr "解析级别“%s”失败"

#: sys-utils/dmesg.c:364
#, c-format
msgid "unknown level '%s'"
msgstr "未知级别“%s”"

#: sys-utils/dmesg.c:400
#, c-format
msgid "failed to parse facility '%s'"
msgstr "解析设施“%s”失败"

#: sys-utils/dmesg.c:402
#, c-format
msgid "unknown facility '%s'"
msgstr "未知设施“%s”"

#: sys-utils/dmesg.c:530
#, c-format
msgid "cannot mmap: %s"
msgstr "无法 mmap：%s"

#: sys-utils/dmesg.c:1436
msgid "invalid buffer size argument"
msgstr "无效的 缓冲区大小 参数"

#: sys-utils/dmesg.c:1488
msgid "--show-delta is ignored when used together with iso8601 time format"
msgstr "--show-delta 与 iso8601 时间格式共用时将忽略"

#: sys-utils/dmesg.c:1511
msgid "--raw can be used together with --level or --facility only when reading messages from /dev/kmsg"
msgstr "只有从 /dev/kmsg 读消息时，--raw 才可与 --level 或 --facility 共用"

#: sys-utils/dmesg.c:1526
msgid "read kernel buffer failed"
msgstr "读取内核缓冲区失败"

#: sys-utils/dmesg.c:1545
msgid "klogctl failed"
msgstr "klogctl 失败"

#: sys-utils/eject.c:135
#, c-format
msgid " %s [options] [<device>|<mountpoint>]\n"
msgstr " %s [选项] [<设备>|<挂臷点>]\n"

#: sys-utils/eject.c:138
msgid "Eject removable media.\n"
msgstr "弹出可移动媒体 \n"

#: sys-utils/eject.c:141
msgid ""
" -a, --auto <on|off>         turn auto-eject feature on or off\n"
" -c, --changerslot <slot>    switch discs on a CD-ROM changer\n"
" -d, --default               display default device\n"
" -f, --floppy                eject floppy\n"
" -F, --force                 don't care about device type\n"
" -i, --manualeject <on|off>  toggle manual eject protection on/off\n"
" -m, --no-unmount            do not unmount device even if it is mounted\n"
" -M, --no-partitions-unmount do not unmount another partitions\n"
" -n, --noop                  don't eject, just show device found\n"
" -p, --proc                  use /proc/mounts instead of /etc/mtab\n"
" -q, --tape                  eject tape\n"
" -r, --cdrom                 eject CD-ROM\n"
" -s, --scsi                  eject SCSI device\n"
" -t, --trayclose             close tray\n"
" -T, --traytoggle            toggle tray\n"
" -v, --verbose               enable verbose output\n"
" -x, --cdspeed <speed>       set CD-ROM max speed\n"
" -X, --listspeed             list CD-ROM available speeds\n"
msgstr ""
" -a, --auto <on|off>         打开/关闭自动弹出功能\n"
" -c, --changerslot <插槽>    在指定 CD-ROM 更换器上换盘\n"
" -d, --default               显示默认设备\n"
" -f, --floppy                弹出软盘\n"
" -F, --force                 无视设备类型\n"
" -i, --manualeject <on|off>  切换手动弹出保护开/关\n"
" -m, --no-unmount            不卸载设备，即使它已挂臷\n"
" -M, --no-partitions-unmount 不卸载另外的分区\n"
" -n, --noop                  不弹出，只显示找到的设备\n"
" -p, --proc                  使用 /proc/mounts 代替 /etc/mtab\n"
" -q, --tape                  弹出磁带\n"
" -r, --cdrom                 弹出 CD-ROM\n"
" -s, --scsi                  弹出 SCSI 设备\n"
" -t, --trayclose             关闭托盘\n"
" -T, --traytoggle            开关托盘\n"
" -v, --verbose               启用详尽输出\n"
" -x, --cdspeed <速度>        设置 CD-ROM 最高速度\n"
" -X, --listspeed             列出 CD-ROM 可用速度\n"

#: sys-utils/eject.c:164
msgid ""
"\n"
"By default tries -r, -s, -f, and -q in order until success.\n"
msgstr ""
"\n"
"默认将依次尝试 -r、-s、-f 和 -q 直到成功。\n"

#: sys-utils/eject.c:210
msgid "invalid argument to --changerslot/-c option"
msgstr "--changerslot/-c 选项的参数无效"

#: sys-utils/eject.c:214
msgid "invalid argument to --cdspeed/-x option"
msgstr "--cdspeed/-x 选项的参数无效"

#: sys-utils/eject.c:325
msgid "CD-ROM auto-eject command failed"
msgstr "CD-ROM 自动弹出命令失败"

#: sys-utils/eject.c:339
msgid "CD-ROM door lock is not supported"
msgstr "不支持光盘仓门锁"

#: sys-utils/eject.c:341
msgid "other users have the drive open and not CAP_SYS_ADMIN"
msgstr "其他用户开启了驱动器仓门，并且非 CAP_SYS_ADMIN"

#: sys-utils/eject.c:343
msgid "CD-ROM lock door command failed"
msgstr "CD-ROM 锁仓门命令失败"

#: sys-utils/eject.c:348
msgid "CD-Drive may NOT be ejected with device button"
msgstr "CD 驱动器不能通过设备上的按钮弹出"

#: sys-utils/eject.c:350
msgid "CD-Drive may be ejected with device button"
msgstr "CD 驱动器可以通过设备上的按钮弹出"

#: sys-utils/eject.c:361
msgid "CD-ROM select disc command failed"
msgstr "CD-ROM 选择光盘命令失败"

#: sys-utils/eject.c:365
msgid "CD-ROM load from slot command failed"
msgstr "CD-ROM 从槽加载命令失败"

#: sys-utils/eject.c:367
msgid "IDE/ATAPI CD-ROM changer not supported by this kernel\n"
msgstr "此内核不支持 IDE/ATAPI CD-ROM\n"

#: sys-utils/eject.c:385
msgid "CD-ROM tray close command failed"
msgstr "CD-ROM 关闭仓门命令失败"

#: sys-utils/eject.c:387
msgid "CD-ROM tray close command not supported by this kernel\n"
msgstr "此内核不支持 CD-ROM 关闭仓门命令\n"

#: sys-utils/eject.c:404
msgid "CD-ROM eject unsupported"
msgstr "不支持 CD-ROM 弹出"

#: sys-utils/eject.c:432 sys-utils/eject.c:455 sys-utils/eject.c:1006
msgid "CD-ROM eject command failed"
msgstr "CD-ROM 弹出命令失败"

#: sys-utils/eject.c:435
msgid "no CD-ROM information available"
msgstr "没有可用的 CD-ROM 信息"

#: sys-utils/eject.c:438
msgid "CD-ROM drive is not ready"
msgstr "CD-ROM 驱动器未就绪"

#: sys-utils/eject.c:481
msgid "CD-ROM select speed command failed"
msgstr "CD-ROM 选择速度命令失败"

#: sys-utils/eject.c:483
msgid "CD-ROM select speed command not supported by this kernel"
msgstr "此内核不支持 CD-ROM 选择速度命令"

#: sys-utils/eject.c:520
#, c-format
msgid "%s: failed to finding CD-ROM name"
msgstr "%s：获取 CD-ROM 名称失败"

#: sys-utils/eject.c:535
#, c-format
msgid "%s: failed to read speed"
msgstr "%s：读 速度 失败"

#: sys-utils/eject.c:543
msgid "failed to read speed"
msgstr "读 速度 失败"

#: sys-utils/eject.c:583
msgid "not an sg device, or old sg driver"
msgstr "不是 sg 设备，或为旧 sg 驱动"

#: sys-utils/eject.c:655
#, c-format
msgid "%s: unmounting"
msgstr "%s：正在卸载"

#: sys-utils/eject.c:673
msgid "unable to fork"
msgstr "无法 fork"

#: sys-utils/eject.c:680
#, c-format
msgid "unmount of `%s' did not exit normally"
msgstr "卸载“%s”未正常退出"

#: sys-utils/eject.c:683
#, c-format
msgid "unmount of `%s' failed\n"
msgstr "挂臷“%s”失败\n"

#: sys-utils/eject.c:725
msgid "failed to parse mount table"
msgstr "解析挂臷表失败"

#: sys-utils/eject.c:786 sys-utils/eject.c:887
#, c-format
msgid "%s: mounted on %s"
msgstr "%s：已挂臷于 %s"

#: sys-utils/eject.c:828
msgid "setting CD-ROM speed to auto"
msgstr "正在将 CD-ROM 速度设置为自动"

#: sys-utils/eject.c:830
#, c-format
msgid "setting CD-ROM speed to %ldX"
msgstr "正在将 CD-ROM 速度设置为 %ldX"

#: sys-utils/eject.c:856
#, c-format
msgid "default device: `%s'"
msgstr "默认设备：“%s”"

#: sys-utils/eject.c:862
#, c-format
msgid "using default device `%s'"
msgstr "使用默认设备“%s”"

#: sys-utils/eject.c:881 sys-utils/rtcwake.c:394
#, c-format
msgid "%s: unable to find device"
msgstr "%s：找不到设备"

#: sys-utils/eject.c:883
#, c-format
msgid "device name is `%s'"
msgstr "设备名称为“%s”"

#: sys-utils/eject.c:889 sys-utils/umount.c:309 sys-utils/umount.c:332
#, c-format
msgid "%s: not mounted"
msgstr "%s：未挂载"

#: sys-utils/eject.c:893
#, c-format
msgid "%s: disc device: %s (disk device will be used for eject)"
msgstr "%s：盘设备：%s(盘设备将用于弹出)"

#: sys-utils/eject.c:901
#, c-format
msgid "%s: not found mountpoint or device with the given name"
msgstr "%s：未找到指定名称的挂载点或设备"

#: sys-utils/eject.c:904
#, c-format
msgid "%s: is whole-disk device"
msgstr "%s：是 整盘 设备"

#: sys-utils/eject.c:908
#, c-format
msgid "%s: is not hot-pluggable device"
msgstr "%s：不是热插拔设备"

#: sys-utils/eject.c:912
#, c-format
msgid "device is `%s'"
msgstr "设备是“%s”"

#: sys-utils/eject.c:913
msgid "exiting due to -n/--noop option"
msgstr "将因 -n/--noop 选项退出"

#: sys-utils/eject.c:927
#, c-format
msgid "%s: enabling auto-eject mode"
msgstr "%s：正在启用自动弹出模式"

#: sys-utils/eject.c:929
#, c-format
msgid "%s: disabling auto-eject mode"
msgstr "%s：正在禁用自动弹出模式"

#: sys-utils/eject.c:937
#, c-format
msgid "%s: closing tray"
msgstr "%s：正在关闭仓门"

#: sys-utils/eject.c:946
#, c-format
msgid "%s: toggling tray"
msgstr "%s：开关仓门"

#: sys-utils/eject.c:955
#, c-format
msgid "%s: listing CD-ROM speed"
msgstr "%s：正在列出 CD-ROM 速度"

#: sys-utils/eject.c:981
#, c-format
msgid "error: %s: device in use"
msgstr "错误：%s：设备正在使用"

#: sys-utils/eject.c:987
#, c-format
msgid "%s: selecting CD-ROM disc #%ld"
msgstr "%s：正在选择 CD-ROM 盘 #%ld"

#: sys-utils/eject.c:1003
#, c-format
msgid "%s: trying to eject using CD-ROM eject command"
msgstr "%s：正在尝试使用 CD-ROM 弹出命令弹出"

#: sys-utils/eject.c:1005
msgid "CD-ROM eject command succeeded"
msgstr "CD-ROM 弹出命令成功"

#: sys-utils/eject.c:1010
#, c-format
msgid "%s: trying to eject using SCSI commands"
msgstr "%s：正在尝试使用 SCSI 命令弹出"

#: sys-utils/eject.c:1012
msgid "SCSI eject succeeded"
msgstr "SCSI 弹出成功"

#: sys-utils/eject.c:1013
msgid "SCSI eject failed"
msgstr "SCSI 弹出失败"

#: sys-utils/eject.c:1017
#, c-format
msgid "%s: trying to eject using floppy eject command"
msgstr "%s：正在尝试使用软盘弹出命令弹出"

#: sys-utils/eject.c:1019
msgid "floppy eject command succeeded"
msgstr "软盘弹出命令成功"

#: sys-utils/eject.c:1020
msgid "floppy eject command failed"
msgstr "软盘弹出命令失败"

#: sys-utils/eject.c:1024
#, c-format
msgid "%s: trying to eject using tape offline command"
msgstr "%s：正在尝试使用磁带离线命令弹出"

#: sys-utils/eject.c:1026
msgid "tape offline command succeeded"
msgstr "磁带离线命令成功"

#: sys-utils/eject.c:1027
msgid "tape offline command failed"
msgstr "磁带离线命令失败"

#: sys-utils/eject.c:1031
msgid "unable to eject"
msgstr "无法弹出"

#: sys-utils/fallocate.c:84
#, c-format
msgid " %s [options] <filename>\n"
msgstr " %s [选项] <文件名>\n"

#: sys-utils/fallocate.c:87
msgid "Preallocate space to, or deallocate space from a file.\n"
msgstr "为文件预分配空间或从文件回收空间。\n"

#: sys-utils/fallocate.c:90
msgid " -c, --collapse-range remove a range from the file\n"
msgstr " -c, --collapse-range 移除文件中的某个范围\n"

#: sys-utils/fallocate.c:91
msgid " -d, --dig-holes      detect zeroes and replace with holes\n"
msgstr " -d, --dig-holes      检测零并替换为空洞\n"

#: sys-utils/fallocate.c:92
msgid " -i, --insert-range   insert a hole at range, shifting existing data\n"
msgstr ""

#: sys-utils/fallocate.c:93
msgid " -l, --length <num>   length for range operations, in bytes\n"
msgstr " -l, --length <数字>  范围操作的长度(字节数)\n"

#: sys-utils/fallocate.c:94
msgid " -n, --keep-size      maintain the apparent size of the file\n"
msgstr " -n, --keep-size      保持文件的显示大小\n"

#: sys-utils/fallocate.c:95
msgid " -o, --offset <num>   offset for range operations, in bytes\n"
msgstr " -o, --offset <数字>  范围操作的偏移量(字节数)\n"

#: sys-utils/fallocate.c:96
msgid " -p, --punch-hole     replace a range with a hole (implies -n)\n"
msgstr " -p, --punch-hole     将某个范围替换为空洞(连带打开 -n)\n"

#: sys-utils/fallocate.c:97
msgid " -z, --zero-range     zero and ensure allocation of a range\n"
msgstr " -z, --zero-range     清零并保证分配某个范围\n"

#: sys-utils/fallocate.c:99
#, fuzzy
msgid " -x, --posix          use posix_fallocate(3) instead of fallocate(2)\n"
msgstr " -y, --physical          打印物理 ID 而非逻辑 ID\n"

#: sys-utils/fallocate.c:135
msgid "fallocate failed: keep size mode is unsupported"
msgstr "fallocate 失败；不支持保持大小(keep size) 模式"

#: sys-utils/fallocate.c:136 sys-utils/fallocate.c:145
msgid "fallocate failed"
msgstr "fallocate 失败"

#: sys-utils/fallocate.c:230
#, c-format
msgid "%s: read failed"
msgstr "%s：read 失败"

#: sys-utils/fallocate.c:271
#, c-format
msgid "%s: %s (%ju bytes) converted to sparse holes.\n"
msgstr "%s：已将 %s(%ju 字节) 转换为稀疏空洞。\n"

#: sys-utils/fallocate.c:354
msgid "posix_fallocate support is not compiled"
msgstr ""

#: sys-utils/fallocate.c:368 sys-utils/fsfreeze.c:107
msgid "no filename specified"
msgstr "未指定文件名"

#: sys-utils/fallocate.c:380 sys-utils/fallocate.c:386
msgid "invalid length value specified"
msgstr "指定的长度值无效"

#: sys-utils/fallocate.c:384
msgid "no length argument specified"
msgstr "没有指定长度参数"

#: sys-utils/fallocate.c:389
msgid "invalid offset value specified"
msgstr "指定的偏移值无效"

#: sys-utils/flock.c:53
#, c-format
msgid ""
" %1$s [options] <file>|<directory> <command> [<argument>...]\n"
" %1$s [options] <file>|<directory> -c <command>\n"
" %1$s [options] <file descriptor number>\n"
msgstr ""
" %1$s [选项] <文件|目录> <命令> [<参数>...]\n"
" %1$s [选项] <文件|目录> -c <命令>\n"
" %1$s [选项] <文件描述符号码>\n"

#: sys-utils/flock.c:59
msgid "Manage file locks from shell scripts.\n"
msgstr "通过 shell 脚本管理文件锁。\n"

#: sys-utils/flock.c:62
msgid " -s, --shared             get a shared lock\n"
msgstr " -s, --shared             获取共享锁\n"

#: sys-utils/flock.c:63
msgid " -x, --exclusive          get an exclusive lock (default)\n"
msgstr " -x, --exclusive          获取排他锁(默认)\n"

#: sys-utils/flock.c:64
msgid " -u, --unlock             remove a lock\n"
msgstr " -u, --unlock             移除锁\n"

#: sys-utils/flock.c:65
msgid " -n, --nonblock           fail rather than wait\n"
msgstr " -n, --nonblock           失败而非等待\n"

#: sys-utils/flock.c:66
msgid " -w, --timeout <secs>     wait for a limited amount of time\n"
msgstr " -w, --timeout <秒>       等待限定的时间\n"

#: sys-utils/flock.c:67
msgid " -E, --conflict-exit-code <number>  exit code after conflict or timeout\n"
msgstr " -E, --conflict-exit-code <数字>     冲突或超时后的退出代码\n"

#: sys-utils/flock.c:68
msgid " -o, --close              close file descriptor before running command\n"
msgstr " -o, --close              运行命令前关闭文件描述符\n"

#: sys-utils/flock.c:69
msgid " -c, --command <command>  run a single command string through the shell\n"
msgstr " -c, --command <命令>      通过 shell 运行单个命令字符串\n"

#: sys-utils/flock.c:70
msgid " -F, --no-fork            execute command without forking\n"
msgstr " -F, --no-fork            执行命令时不 fork\n"

#: sys-utils/flock.c:71
msgid "     --verbose            increase verbosity\n"
msgstr "     --verbose            增加详尽程度\n"

#: sys-utils/flock.c:106
#, c-format
msgid "cannot open lock file %s"
msgstr "不能打开锁文件 %s"

#: sys-utils/flock.c:208
msgid "invalid timeout value"
msgstr "无效的 超时值"

#: sys-utils/flock.c:212
msgid "invalid exit code"
msgstr "无效退出代码"

#: sys-utils/flock.c:229
msgid "the --no-fork and --close options are incompatible"
msgstr "--no-fork 和 --close 选项不兼容"

#: sys-utils/flock.c:237
#, c-format
msgid "%s requires exactly one command argument"
msgstr "%s 需要惟一的命令行参数"

#: sys-utils/flock.c:255
msgid "bad file descriptor"
msgstr "错误的文件描述符"

#: sys-utils/flock.c:258
msgid "requires file descriptor, file or directory"
msgstr "需要文件描述符、文件或目录"

#: sys-utils/flock.c:282
msgid "failed to get lock"
msgstr "获取锁失败"

#: sys-utils/flock.c:289
msgid "timeout while waiting to get lock"
msgstr "等待获得锁超时"

#: sys-utils/flock.c:330
#, c-format
msgid "%s: getting lock took %ld.%06ld seconds\n"
msgstr "%s：等待获得锁花了 %ld.%06ld 秒\n"

#: sys-utils/flock.c:341
#, c-format
msgid "%s: executing %s\n"
msgstr "%s: 正在执行 %s\n"

#: sys-utils/fsfreeze.c:41
#, c-format
msgid " %s [options] <mountpoint>\n"
msgstr " %s [选项] <挂臷点>\n"

#: sys-utils/fsfreeze.c:44
#, fuzzy
msgid "Suspend access to a filesystem.\n"
msgstr "挂载文件系统。\n"

#: sys-utils/fsfreeze.c:47
msgid " -f, --freeze      freeze the filesystem\n"
msgstr " -f, --freeze      冻结文件系统\n"

#: sys-utils/fsfreeze.c:48
msgid " -u, --unfreeze    unfreeze the filesystem\n"
msgstr " -u, --unfreeze    解冻文件系统\n"

#: sys-utils/fsfreeze.c:105
msgid "neither --freeze or --unfreeze specified"
msgstr "既未指定 --freeze 也未指定 --unfreeze"

#: sys-utils/fsfreeze.c:125
#, c-format
msgid "%s: is not a directory"
msgstr "%s：不是目录"

#: sys-utils/fsfreeze.c:132
#, c-format
msgid "%s: freeze failed"
msgstr "%s：冻结失败"

#: sys-utils/fsfreeze.c:138
#, c-format
msgid "%s: unfreeze failed"
msgstr "%s：解冻失败"

#: sys-utils/fstrim.c:84
#, c-format
msgid "%s: not a directory"
msgstr "%s：不是一个目录"

#: sys-utils/fstrim.c:93
#, c-format
msgid "%s: FITRIM ioctl failed"
msgstr "%s：FITRIM ioctl 失败"

#. TRANSLATORS: The standard value here is a very large number.
#: sys-utils/fstrim.c:102
#, c-format
msgid "%s: %s (%<PRIu64> bytes) trimmed\n"
msgstr "%s：%s (%<PRIu64> 字节) 已修剪\n"

#: sys-utils/fstrim.c:193 sys-utils/lsns.c:1066 sys-utils/swapon.c:733
#: sys-utils/umount.c:229
#, c-format
msgid "failed to parse %s"
msgstr "解析 %s 失败"

#: sys-utils/fstrim.c:254
#, c-format
msgid " %s [options] <mount point>\n"
msgstr " %s [选项] <挂臷点>\n"

#: sys-utils/fstrim.c:257
msgid "Discard unused blocks on a mounted filesystem.\n"
msgstr "忽略已挂载文件系统上的未用锁。\n"

#: sys-utils/fstrim.c:260
msgid " -a, --all           trim all mounted filesystems that are supported\n"
msgstr " -a, --all           修剪不支持的所有已挂载文件系统\n"

#: sys-utils/fstrim.c:261
msgid " -o, --offset <num>  the offset in bytes to start discarding from\n"
msgstr " -o, --offset <数字> 开始丢弃的偏移量(字节)\n"

#: sys-utils/fstrim.c:262
msgid " -l, --length <num>  the number of bytes to discard\n"
msgstr " -l, --length <数字> 要丢弃的字符数\n"

#: sys-utils/fstrim.c:263
msgid " -m, --minimum <num> the minimum extent length to discard\n"
msgstr " -m, --minimum <数字> 要丢弃的最小限制长度\n"

#: sys-utils/fstrim.c:264
msgid " -v, --verbose       print number of discarded bytes\n"
msgstr " -v, --verbose       打印丢弃的字节数\n"

#: sys-utils/fstrim.c:318
msgid "failed to parse minimum extent length"
msgstr "解析 最小范围长度 失败"

#: sys-utils/fstrim.c:331
msgid "no mountpoint specified"
msgstr "未指定挂载点"

#: sys-utils/fstrim.c:345
#, c-format
msgid "%s: the discard operation is not supported"
msgstr "%s：不支持丢弃操作"

#: sys-utils/hwclock.c:203
#, c-format
msgid "Assuming hardware clock is kept in %s time.\n"
msgstr "将假设硬件时钟保持为 %s 时间。\n"

#: sys-utils/hwclock.c:204 sys-utils/hwclock.c:268
msgid "UTC"
msgstr "UTC"

#: sys-utils/hwclock.c:204 sys-utils/hwclock.c:267
msgid "local"
msgstr "当地"

#: sys-utils/hwclock.c:254
msgid ""
"Warning: unrecognized third line in adjtime file\n"
"(Expected: `UTC' or `LOCAL' or nothing.)"
msgstr ""
"警告：adjtime 文件第三行无法识别\n"
"(应为：“UTC”或“LOCAL”或空)"

#: sys-utils/hwclock.c:261
#, c-format
msgid "Last drift adjustment done at %ld seconds after 1969\n"
msgstr "上次漂移调整完成于1969(年)后 %ld 秒\n"

#: sys-utils/hwclock.c:263
#, c-format
msgid "Last calibration done at %ld seconds after 1969\n"
msgstr "上次校准完成于1969(年)后 %ld 秒\n"

#: sys-utils/hwclock.c:265
#, c-format
msgid "Hardware clock is on %s time\n"
msgstr "硬件时钟为 %s 时间\n"

#: sys-utils/hwclock.c:292
#, c-format
msgid "Waiting for clock tick...\n"
msgstr "正在等等时钟滴答...\n"

#: sys-utils/hwclock.c:298
#, c-format
msgid "...synchronization failed\n"
msgstr "...同步失败\n"

#: sys-utils/hwclock.c:300
#, c-format
msgid "...got clock tick\n"
msgstr "...已获取时钟滴答\n"

#: sys-utils/hwclock.c:341
#, c-format
msgid "Invalid values in hardware clock: %4d/%.2d/%.2d %.2d:%.2d:%.2d\n"
msgstr "硬件时钟值无效：%4d/%.2d/%.2d %.2d:%.2d:%.2d\n"

#: sys-utils/hwclock.c:349
#, c-format
msgid "Hw clock time : %4d/%.2d/%.2d %.2d:%.2d:%.2d = %ld seconds since 1969\n"
msgstr "硬件时钟时间：%4d/%.2d/%.2d %.2d:%.2d:%.2d = 1969(年)后 %ld 秒\n"

#: sys-utils/hwclock.c:376
#, c-format
msgid "Time read from Hardware Clock: %4d/%.2d/%.2d %02d:%02d:%02d\n"
msgstr "从硬件时钟读取的时间：%4d/%.2d/%.2d %02d:%02d:%02d\n"

#: sys-utils/hwclock.c:403
#, c-format
msgid "Setting Hardware Clock to %.2d:%.2d:%.2d = %ld seconds since 1969\n"
msgstr "正在将硬件时钟设置为 %.2d:%.2d:%.2d = 1969(年)后 %ld 秒\n"

#: sys-utils/hwclock.c:505
#, c-format
msgid "time jumped backward %.6f seconds to %ld.%06ld - retargeting\n"
msgstr "时间倒退了 %.6f 秒到 %ld.%06ld - 正在重新定位\n"

#: sys-utils/hwclock.c:527
#, c-format
msgid "missed it - %ld.%06ld is too far past %ld.%06ld (%.6f > %.6f)\n"
msgstr "错过了- %ld.%06ld 在 %ld.%06ld 之后太长时间了(%.6f > %.6f)\n"

#: sys-utils/hwclock.c:555
#, fuzzy, c-format
msgid ""
"%ld.%06ld is close enough to %ld.%06ld (%.6f < %.6f)\n"
"Set RTC to %ld (%ld + %d; refsystime = %ld.%06ld)\n"
msgstr ""
"%ld.%06d 距 %ld.%06d 太近(%.6f < %.6f)\n"
"请将 RTC 设为 %ld (%ld + %d; refsystime = %ld.%06d)\n"

#: sys-utils/hwclock.c:625
#, c-format
msgid "Calling settimeofday(NULL, %d) to set persistent_clock_is_local.\n"
msgstr ""

#: sys-utils/hwclock.c:628
msgid "Calling settimeofday(NULL, 0) to lock the warp function."
msgstr ""

#: sys-utils/hwclock.c:631
#, fuzzy, c-format
msgid "Calling settimeofday(%ld.%06ld, %d)\n"
msgstr "正在调用 settimeofday：\n"

#: sys-utils/hwclock.c:634
#, fuzzy, c-format
msgid "Calling settimeofday(NULL, %d) "
msgstr "正在调用 settimeofday：\n"

#: sys-utils/hwclock.c:636
msgid "to set the kernel timezone."
msgstr ""

#: sys-utils/hwclock.c:638
msgid "to warp System time."
msgstr ""

#: sys-utils/hwclock.c:655
msgid "settimeofday() failed"
msgstr "settimeofday() 失败"

#: sys-utils/hwclock.c:679
#, c-format
msgid "Not adjusting drift factor because the --update-drift option was not used.\n"
msgstr "将不调整漂移系数，因为没有使用 --update-drift 选项。\n"

#: sys-utils/hwclock.c:683
#, c-format
msgid ""
"Not adjusting drift factor because last calibration time is zero,\n"
"so history is bad and calibration startover is necessary.\n"
msgstr ""
"将不调整漂移系数，因为上次校准时间为零，\n"
"历史有问题；需要启动校准。\n"

#: sys-utils/hwclock.c:689
#, c-format
msgid "Not adjusting drift factor because it has been less than four hours since the last calibration.\n"
msgstr "将不调整漂移系数，因为距上次校正不到四个小时。\n"

#: sys-utils/hwclock.c:727
#, c-format
msgid ""
"Clock drift factor was calculated as %f seconds/day.\n"
"It is far too much. Resetting to zero.\n"
msgstr ""
"时钟漂移系数会按 %f 秒/天计算。\n"
"系数过大，将重置为 0。\n"

#: sys-utils/hwclock.c:734
#, fuzzy, c-format
msgid ""
"Clock drifted %f seconds in the past %f seconds\n"
"in spite of a drift factor of %f seconds/day.\n"
"Adjusting drift factor by %f seconds/day\n"
msgstr "在过去的 %2$d 秒内，时钟漂移了 %1$.1f 秒，而漂移系数为 %3$f 秒/天。会将漂移系数调整 %4$f 秒/天\n"

#: sys-utils/hwclock.c:778
#, fuzzy, c-format
msgid "Time since last adjustment is %ld second\n"
msgid_plural "Time since last adjustment is %ld seconds\n"
msgstr[0] "距上次调整的时间为 %d 秒\n"

#: sys-utils/hwclock.c:782
#, c-format
msgid "Calculated Hardware Clock drift is %ld.%06ld seconds\n"
msgstr "计算出的硬件锁偏差为 %ld.%06ld 秒\n"

#: sys-utils/hwclock.c:807
#, c-format
msgid ""
"New %s data:\n"
"%s"
msgstr ""

#: sys-utils/hwclock.c:817
#, fuzzy, c-format
msgid "cannot update %s"
msgstr "打不开 %s"

#: sys-utils/hwclock.c:853
#, c-format
msgid "Not setting clock because last adjustment time is zero, so history is bad.\n"
msgstr "将不设置时钟，因为上次调整时间为零，历史有误。\n"

#: sys-utils/hwclock.c:857
#, c-format
msgid "Not setting clock because drift factor %f is far too high.\n"
msgstr "将不设置时钟，因为上次漂移系数 %f 过高。\n"

#: sys-utils/hwclock.c:885
#, c-format
msgid "No usable clock interface found.\n"
msgstr "未找到可用的时钟接口。\n"

#: sys-utils/hwclock.c:886
msgid "Cannot access the Hardware Clock via any known method."
msgstr "无法通过已知的任何方式访问硬件时钟。"

#: sys-utils/hwclock.c:889
#, fuzzy
msgid "Use the --verbose option to see the details of our search for an access method."
msgstr "请使用 --debug 选项来观察程序搜索访问方法的详情。"

#: sys-utils/hwclock.c:939
#, c-format
msgid "Target date:   %ld\n"
msgstr ""

#: sys-utils/hwclock.c:940
#, c-format
msgid "Predicted RTC: %ld\n"
msgstr ""

#: sys-utils/hwclock.c:970
msgid "RTC read returned an invalid value."
msgstr ""

#: sys-utils/hwclock.c:998
#, c-format
msgid "Needed adjustment is less than one second, so not setting clock.\n"
msgstr "需要的调整不到一秒，将不设置时钟。\n"

#: sys-utils/hwclock.c:1035
#, fuzzy
msgid "unable to read the RTC epoch."
msgstr "不能读超级块"

#: sys-utils/hwclock.c:1037
#, c-format
msgid "The RTC epoch is set to %lu.\n"
msgstr ""

#: sys-utils/hwclock.c:1040
msgid "--epoch is required for --setepoch."
msgstr ""

#: sys-utils/hwclock.c:1043
#, fuzzy
msgid "unable to set the RTC epoch."
msgstr "无法设置系统时钟。\n"

#: sys-utils/hwclock.c:1057
#, fuzzy, c-format
msgid " %s [function] [option...]\n"
msgstr " hwclock [功能] [选项...]\n"

#: sys-utils/hwclock.c:1060
msgid "Time clocks utility."
msgstr ""

#: sys-utils/hwclock.c:1063
#, fuzzy
msgid " -r, --show           display the RTC time"
msgstr " -r, --raw                以原始方式显示\n"

#: sys-utils/hwclock.c:1064
#, fuzzy
msgid "     --get            display drift corrected RTC time"
msgstr " -Z, --context            显示 SELinux 环境\n"

#: sys-utils/hwclock.c:1065
#, fuzzy
msgid "     --set            set the RTC according to --date"
msgstr " -r, --reset                  重置端口\n"

#: sys-utils/hwclock.c:1066
msgid " -s, --hctosys        set the system time from the RTC"
msgstr ""

#: sys-utils/hwclock.c:1067
#, fuzzy
msgid " -w, --systohc        set the RTC from the system time"
msgstr " -t, --types <列表>      限制文件系统集合\n"

#: sys-utils/hwclock.c:1068
msgid "     --systz          send timescale configurations to the kernel"
msgstr ""

#: sys-utils/hwclock.c:1069
msgid " -a, --adjust         adjust the RTC to account for systematic drift"
msgstr ""

#: sys-utils/hwclock.c:1071
#, fuzzy
msgid "     --getepoch       display the RTC epoch"
msgstr "     --help                 显示此帮助并退出\n"

#: sys-utils/hwclock.c:1072
msgid "     --setepoch       set the RTC epoch according to --epoch"
msgstr ""

#: sys-utils/hwclock.c:1074
msgid "     --predict        predict the drifted RTC time according to --date"
msgstr ""

#: sys-utils/hwclock.c:1076
#, fuzzy
msgid " -u, --utc            the RTC timescale is UTC"
msgstr " -u, --utc                RTC 使用 UTC\n"

#: sys-utils/hwclock.c:1077
#, fuzzy
msgid " -l, --localtime      the RTC timescale is Local"
msgstr " -l, --local              RTC 使用本地时区\n"

#: sys-utils/hwclock.c:1080
#, fuzzy, c-format
msgid " -f, --rtc <file>     use an alternate file to %1$s\n"
msgstr " -F, --file <文件>    用指定文件代替 %s\n"

#: sys-utils/hwclock.c:1083
#, c-format
msgid "     --directisa      use the ISA bus instead of %1$s access\n"
msgstr ""

#: sys-utils/hwclock.c:1084
#, fuzzy
msgid "     --date <time>    date/time input for --set and --predict"
msgstr "     --date <时间戳>      唤醒时间戳的日期时间\n"

#: sys-utils/hwclock.c:1086
msgid "     --epoch <year>   epoch input for --setepoch"
msgstr ""

#: sys-utils/hwclock.c:1088
msgid "     --update-drift   update the RTC drift factor"
msgstr ""

#: sys-utils/hwclock.c:1090
#, fuzzy, c-format
msgid "     --noadjfile      do not use %1$s\n"
msgstr "      --noheadings     不打印标题\n"

#: sys-utils/hwclock.c:1092
#, fuzzy, c-format
msgid "     --adjfile <file> use an alternate file to %1$s\n"
msgstr " -F, --file <文件>    用指定文件代替 %s\n"

#: sys-utils/hwclock.c:1093
#, fuzzy
msgid "     --test           dry run; implies --verbose"
msgstr "     --fake              空运行；跳过 umount(2) 系统调用\n"

#: sys-utils/hwclock.c:1094
#, fuzzy
msgid " -v, --verbose        display more details"
msgstr "     --verbose          打印更多细节\n"

#: sys-utils/hwclock.c:1186
msgid "Unable to connect to audit system"
msgstr "无法连接到审计系统"

#: sys-utils/hwclock.c:1210
msgid "use --verbose, --debug has been deprecated."
msgstr ""

#: sys-utils/hwclock.c:1309
#, fuzzy, c-format
msgid "%d too many arguments given"
msgstr "参数过多"

#: sys-utils/hwclock.c:1317
msgid "--update-drift requires --set or --systohc"
msgstr ""

#: sys-utils/hwclock.c:1322
msgid "With --noadjfile, you must specify either --utc or --localtime"
msgstr "指定 --noadjfile 时，您必须指定 --utc 或 --localtime"

#: sys-utils/hwclock.c:1329
msgid "--date is required for --set or --predict"
msgstr ""

#: sys-utils/hwclock.c:1335
#, fuzzy, c-format
msgid "invalid date '%s'"
msgstr "无效 ID：%s"

#: sys-utils/hwclock.c:1349
#, fuzzy, c-format
msgid "System Time: %ld.%06ld\n"
msgstr "当前系统时间：%ld = %s\n"

#: sys-utils/hwclock.c:1365
#, fuzzy
msgid "Test mode: nothing was changed."
msgstr "上次更改时间"

#: sys-utils/hwclock-cmos.c:389
#, fuzzy
msgid "ISA port access is not implemented"
msgstr "plymouth 请求 %c 没有实现"

#: sys-utils/hwclock-cmos.c:391
#, fuzzy
msgid "iopl() port access failed"
msgstr "无法访问文件 %s"

#: sys-utils/hwclock-cmos.c:397
#, fuzzy
msgid "Using direct ISA access to the clock"
msgstr "将对 ISA 时钟使用直接 I/O 指令。"

#: sys-utils/hwclock-rtc.c:128
#, fuzzy, c-format
msgid "Trying to open: %s\n"
msgstr "正在尝试卸载 %s\n"

#: sys-utils/hwclock-rtc.c:150 sys-utils/hwclock-rtc.c:253
#, fuzzy
msgid "cannot open rtc device"
msgstr "打不开 "

#: sys-utils/hwclock-rtc.c:186
#, c-format
msgid "ioctl(%s) to %s to read the time failed"
msgstr "对 %2$s 的读取时间 ioctl(%1$s) 失败"

#: sys-utils/hwclock-rtc.c:214
#, c-format
msgid "Waiting in loop for time from %s to change\n"
msgstr "正在循环等待来自 %s 的时间更改\n"

#: sys-utils/hwclock-rtc.c:233
msgid "Timed out waiting for time change."
msgstr "等待时间更改超时。"

#: sys-utils/hwclock-rtc.c:289
#, c-format
msgid "select() to %s to wait for clock tick timed out"
msgstr "对 %s select() 以等待时钟嘀嗒超时"

#: sys-utils/hwclock-rtc.c:292
#, c-format
msgid "select() to %s to wait for clock tick failed"
msgstr "对 %s select() 以等待时钟嘀嗒失败"

#: sys-utils/hwclock-rtc.c:297
#, c-format
msgid "ioctl() to %s to turn off update interrupts failed"
msgstr "对 %s ioctl() 以关闭更新中断失败"

#: sys-utils/hwclock-rtc.c:303
#, fuzzy, c-format
msgid "ioctl(%d, RTC_UIE_ON, 0) to %s failed"
msgstr "对 %s 进行 ioctl(RTC_EPOCH_SET) 失败"

#: sys-utils/hwclock-rtc.c:356
#, fuzzy, c-format
msgid "ioctl(%s) to %s to set the time failed"
msgstr "对 %2$s ioctl(%1$s) 以设置时间失败。"

#: sys-utils/hwclock-rtc.c:362
#, c-format
msgid "ioctl(%s) was successful.\n"
msgstr "ioctl(%s) 成功。\n"

#: sys-utils/hwclock-rtc.c:373
#, fuzzy
msgid "Using the rtc interface to the clock."
msgstr "将对时钟使用 /dev 接口。"

#: sys-utils/hwclock-rtc.c:405
#, fuzzy, c-format
msgid "ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s failed"
msgstr "对 %s 进行 ioctl(RTC_EPOCH_READ) 失败"

#: sys-utils/hwclock-rtc.c:411
#, fuzzy, c-format
msgid "ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s succeeded.\n"
msgstr "对 %s 进行 ioctl(RTC_EPOCH_READ) 失败"

#: sys-utils/hwclock-rtc.c:429
#, fuzzy, c-format
msgid "invalid epoch '%s'."
msgstr "无效 ID：%s"

#: sys-utils/hwclock-rtc.c:440
#, fuzzy, c-format
msgid "ioctl(%d, RTC_EPOCH_SET, %lu) to %s failed"
msgstr "对 %s 进行 ioctl(RTC_EPOCH_SET) 失败"

#: sys-utils/hwclock-rtc.c:446
#, fuzzy, c-format
msgid "ioctl(%d, RTC_EPOCH_SET, %lu) to %s succeeded.\n"
msgstr "对 %s 进行 ioctl(RTC_EPOCH_SET) 失败"

#: sys-utils/ipcmk.c:70
msgid "Create various IPC resources.\n"
msgstr "创建各种 IPC 资源。\n"

#: sys-utils/ipcmk.c:73
msgid " -M, --shmem <size>       create shared memory segment of size <size>\n"
msgstr " -M, --shmem <尺寸>       创建大小为指定<尺寸>的共享内存段。\n"

#: sys-utils/ipcmk.c:74
msgid " -S, --semaphore <number> create semaphore array with <number> elements\n"
msgstr " -S, --semaphore <数字>   创建包含 <数字> 个元素的信号量\n"

#: sys-utils/ipcmk.c:75
msgid " -Q, --queue              create message queue\n"
msgstr " -Q, --queue              创建消息队列\n"

#: sys-utils/ipcmk.c:76
msgid " -p, --mode <mode>        permission for the resource (default is 0644)\n"
msgstr " -p, --mode <模式>        资源的权限模式掩码(默认为 0644)\n"

#: sys-utils/ipcmk.c:110 sys-utils/losetup.c:715 sys-utils/zramctl.c:629
msgid "failed to parse size"
msgstr "解析大小失败"

#: sys-utils/ipcmk.c:117
msgid "failed to parse elements"
msgstr "解析元素失败"

#: sys-utils/ipcmk.c:141
msgid "create share memory failed"
msgstr "创建共享内存失败"

#: sys-utils/ipcmk.c:143
#, c-format
msgid "Shared memory id: %d\n"
msgstr "共享内存 id：%d\n"

#: sys-utils/ipcmk.c:149
msgid "create message queue failed"
msgstr "创建消息队列失败"

#: sys-utils/ipcmk.c:151
#, c-format
msgid "Message queue id: %d\n"
msgstr "消息队列 id：%d\n"

#: sys-utils/ipcmk.c:157
msgid "create semaphore failed"
msgstr "创建信号量失败"

#: sys-utils/ipcmk.c:159
#, c-format
msgid "Semaphore id: %d\n"
msgstr "信号量 id：%d\n"

#: sys-utils/ipcrm.c:51
#, c-format
msgid ""
" %1$s [options]\n"
" %1$s shm|msg|sem <id>...\n"
msgstr ""
" %1$s [选项]\n"
" %1$s shm|msg|sem <id>...\n"

#: sys-utils/ipcrm.c:55
msgid "Remove certain IPC resources.\n"
msgstr "移除某个 IPC 资源。\n"

#: sys-utils/ipcrm.c:58
msgid " -m, --shmem-id <id>        remove shared memory segment by id\n"
msgstr " -m, --shmem-id <id>        按 id 号移除共享内存段\n"

#: sys-utils/ipcrm.c:59
msgid " -M, --shmem-key <key>      remove shared memory segment by key\n"
msgstr " -M, --shmem-key <键>       按键值移除共享内存段\n"

#: sys-utils/ipcrm.c:60
msgid " -q, --queue-id <id>        remove message queue by id\n"
msgstr " -q, --queue-id <id>        按 id 号移除消息队列\n"

#: sys-utils/ipcrm.c:61
msgid " -Q, --queue-key <key>      remove message queue by key\n"
msgstr " -Q, --queue-key <键>       按键值移除消息队列\n"

#: sys-utils/ipcrm.c:62
msgid " -s, --semaphore-id <id>    remove semaphore by id\n"
msgstr " -s, --semaphore-id <id>    按 id 号移除信号量\n"

#: sys-utils/ipcrm.c:63
msgid " -S, --semaphore-key <key>  remove semaphore by key\n"
msgstr " -S, --semaphore-key <键>  按键值移除信号量\n"

#: sys-utils/ipcrm.c:64
msgid " -a, --all[=shm|msg|sem]    remove all (in the specified category)\n"
msgstr " -a, --all[=<shm|msg|sem>]  (将指定类别中的)全部移除\n"

#: sys-utils/ipcrm.c:65
msgid " -v, --verbose              explain what is being done\n"
msgstr " -v, --verbose              解释正在进行的操作\n"

#: sys-utils/ipcrm.c:86
#, c-format
msgid "removing shared memory segment id `%d'\n"
msgstr "正在移除共享内存段 id “%d”\n"

#: sys-utils/ipcrm.c:91
#, c-format
msgid "removing message queue id `%d'\n"
msgstr "正在移除消息队列 id “%d”\n"

#: sys-utils/ipcrm.c:96
#, c-format
msgid "removing semaphore id `%d'\n"
msgstr "正在移除信号量 id “%d”\n"

#: sys-utils/ipcrm.c:108 sys-utils/ipcrm.c:222
msgid "permission denied for key"
msgstr "对 键 的权限不足"

#: sys-utils/ipcrm.c:108
msgid "permission denied for id"
msgstr "对 id 的权限不足"

#: sys-utils/ipcrm.c:111 sys-utils/ipcrm.c:228
msgid "invalid key"
msgstr "无效键"

#: sys-utils/ipcrm.c:111
msgid "invalid id"
msgstr "无效 id"

#: sys-utils/ipcrm.c:114 sys-utils/ipcrm.c:225
msgid "already removed key"
msgstr "已移除的键"

#: sys-utils/ipcrm.c:114
msgid "already removed id"
msgstr "已移除的 id"

#: sys-utils/ipcrm.c:117 sys-utils/ipcrm.c:231
msgid "key failed"
msgstr "键失败"

#: sys-utils/ipcrm.c:117
msgid "id failed"
msgstr "ID 失败"

#: sys-utils/ipcrm.c:134
#, c-format
msgid "invalid id: %s"
msgstr "无效 ID：%s"

#: sys-utils/ipcrm.c:167
#, c-format
msgid "resource(s) deleted\n"
msgstr "资源已删除\n"

#: sys-utils/ipcrm.c:200
#, c-format
msgid "illegal key (%s)"
msgstr "非法的键(%s)"

#: sys-utils/ipcrm.c:256
msgid "kernel not configured for shared memory"
msgstr "内核未做共享内存的相关配置"

#: sys-utils/ipcrm.c:269
msgid "kernel not configured for semaphores"
msgstr "内核未做信号量的相关配置"

#: sys-utils/ipcrm.c:290
msgid "kernel not configured for message queues"
msgstr "内核未做消息的相关配置"

#: sys-utils/ipcs.c:53
#, c-format
msgid ""
" %1$s [resource-option...] [output-option]\n"
" %1$s -m|-q|-s -i <id>\n"
msgstr ""
" %1$s [资源选项...] [输出选项]\n"
" %1$s -m|-q|-s -i <id>\n"

#: sys-utils/ipcs.c:57 sys-utils/lsipc.c:281
msgid "Show information on IPC facilities.\n"
msgstr "显示 IPC 设施的信息。\n"

#: sys-utils/ipcs.c:60
msgid " -i, --id <id>  print details on resource identified by <id>\n"
msgstr " -i, --id <id>  打印由<id>标识的资源的详细信息\n"

#: sys-utils/ipcs.c:64 sys-utils/lsipc.c:284
msgid "Resource options:\n"
msgstr "资源选项：\n"

#: sys-utils/ipcs.c:65 sys-utils/lsipc.c:285
msgid " -m, --shmems      shared memory segments\n"
msgstr " -m, --shmems      共享内存段\n"

#: sys-utils/ipcs.c:66 sys-utils/lsipc.c:286
msgid " -q, --queues      message queues\n"
msgstr " -q, --queues      消息队列\n"

#: sys-utils/ipcs.c:67 sys-utils/lsipc.c:287
msgid " -s, --semaphores  semaphores\n"
msgstr " -s, --semaphores  信号量\n"

#: sys-utils/ipcs.c:68
msgid " -a, --all         all (default)\n"
msgstr " -a, --all         全部(默认)\n"

#: sys-utils/ipcs.c:71
msgid "Output options:\n"
msgstr "输出选项：\n"

#: sys-utils/ipcs.c:72
msgid " -t, --time        show attach, detach and change times\n"
msgstr " -t, --time        显示附加、脱离和更改时间\n"

#: sys-utils/ipcs.c:73
msgid " -p, --pid         show PIDs of creator and last operator\n"
msgstr " -p, --pid         显示创建者和最后操作者的 PID\n"

#: sys-utils/ipcs.c:74
msgid " -c, --creator     show creator and owner\n"
msgstr " -c, --creator     显示创建者和拥有者\n"

#: sys-utils/ipcs.c:75
msgid " -l, --limits      show resource limits\n"
msgstr " -l, --limits      显示资源限制\n"

#: sys-utils/ipcs.c:76
msgid " -u, --summary     show status summary\n"
msgstr " -u, --summary     显示状态摘要\n"

#: sys-utils/ipcs.c:77
msgid "     --human       show sizes in human-readable format\n"
msgstr "     --human       以易读格式显示大小\n"

#: sys-utils/ipcs.c:78
msgid " -b, --bytes       show sizes in bytes\n"
msgstr " -b, --bytes       以字节数显示大小\n"

#: sys-utils/ipcs.c:164
msgid "when using an ID, a single resource must be specified"
msgstr "使用 ID 时，必须指定一个资源"

#: sys-utils/ipcs.c:204
#, c-format
msgid "unable to fetch shared memory limits\n"
msgstr "无法获取共享内存限制\n"

#: sys-utils/ipcs.c:207
#, c-format
msgid "------ Shared Memory Limits --------\n"
msgstr "---------- 同享内存限制 ------------\n"

#: sys-utils/ipcs.c:208
#, c-format
msgid "max number of segments = %ju\n"
msgstr "最大段数 = %ju\n"

#: sys-utils/ipcs.c:210
msgid "max seg size"
msgstr "最大段大小"

#: sys-utils/ipcs.c:218
msgid "max total shared memory"
msgstr "最大总共享内存"

#: sys-utils/ipcs.c:220
msgid "min seg size"
msgstr "最小段大小"

#: sys-utils/ipcs.c:232
#, c-format
msgid "kernel not configured for shared memory\n"
msgstr "内核未做共享内存的相关配置\n"

#: sys-utils/ipcs.c:236
#, c-format
msgid "------ Shared Memory Status --------\n"
msgstr "---------- 共享内存状态 ------------\n"

#. TRANSLATORS: This output format is maintained for backward
#. compatibility as ipcs is used in scripts. For consistency
#. with the rest, the translated form can follow this model:
#. *
#. "segments allocated = %d\n"
#. "pages allocated = %ld\n"
#. "pages resident = %ld\n"
#. "pages swapped = %ld\n"
#. "swap performance = %ld attempts, %ld successes\n"
#.
#: sys-utils/ipcs.c:248
#, c-format
msgid ""
"segments allocated %d\n"
"pages allocated %ld\n"
"pages resident  %ld\n"
"pages swapped   %ld\n"
"Swap performance: %ld attempts\t %ld successes\n"
msgstr ""
"段已分配 %d\n"
"页已分配 %ld\n"
"页驻留  %ld\n"
"页交换  %ld\n"
"交换性能：%ld 次尝试\t %ld 次成功\n"

#: sys-utils/ipcs.c:265
#, c-format
msgid "------ Shared Memory Segment Creators/Owners --------\n"
msgstr "------------- 共享内存段创建者/拥有者 ---------------\n"

#: sys-utils/ipcs.c:267 sys-utils/ipcs.c:273 sys-utils/ipcs.c:280
#: sys-utils/ipcs.c:286
msgid "shmid"
msgstr "shmid"

#: sys-utils/ipcs.c:267 sys-utils/ipcs.c:286 sys-utils/ipcs.c:392
#: sys-utils/ipcs.c:407 sys-utils/ipcs.c:495 sys-utils/ipcs.c:513
msgid "perms"
msgstr "权限"

#: sys-utils/ipcs.c:267 sys-utils/ipcs.c:392 sys-utils/ipcs.c:495
msgid "cuid"
msgstr "cuid"

#: sys-utils/ipcs.c:267 sys-utils/ipcs.c:392 sys-utils/ipcs.c:495
msgid "cgid"
msgstr "cgid"

#: sys-utils/ipcs.c:267 sys-utils/ipcs.c:392 sys-utils/ipcs.c:495
msgid "uid"
msgstr "uid"

#: sys-utils/ipcs.c:267 sys-utils/ipcs.c:392 sys-utils/ipcs.c:495
msgid "gid"
msgstr "gid"

#: sys-utils/ipcs.c:271
#, c-format
msgid "------ Shared Memory Attach/Detach/Change Times --------\n"
msgstr "------------ 共享内存 附加/脱离/更改 时间 --------------\n"

#: sys-utils/ipcs.c:273 sys-utils/ipcs.c:280 sys-utils/ipcs.c:286
#: sys-utils/ipcs.c:398 sys-utils/ipcs.c:407 sys-utils/ipcs.c:501
#: sys-utils/ipcs.c:507 sys-utils/ipcs.c:513
msgid "owner"
msgstr "拥有者"

#: sys-utils/ipcs.c:273
msgid "attached"
msgstr "已附加"

#: sys-utils/ipcs.c:273
msgid "detached"
msgstr "已断开"

#: sys-utils/ipcs.c:274
msgid "changed"
msgstr "已更改"

#: sys-utils/ipcs.c:278
#, c-format
msgid "------ Shared Memory Creator/Last-op PIDs --------\n"
msgstr "-------- 共享内存 创建者/上次修改者 PID ----------\n"

#: sys-utils/ipcs.c:280
msgid "cpid"
msgstr "cpid"

#: sys-utils/ipcs.c:280
msgid "lpid"
msgstr "lpid"

#: sys-utils/ipcs.c:284
#, c-format
msgid "------ Shared Memory Segments --------\n"
msgstr "------------ 共享内存段 --------------\n"

#: sys-utils/ipcs.c:286 sys-utils/ipcs.c:407 sys-utils/ipcs.c:513
msgid "key"
msgstr "键"

#: sys-utils/ipcs.c:287 sys-utils/ipcs.c:514
msgid "size"
msgstr "大小"

#: sys-utils/ipcs.c:287 sys-utils/prlimit.c:75 sys-utils/prlimit.c:76
#: sys-utils/prlimit.c:78 sys-utils/prlimit.c:79 sys-utils/prlimit.c:81
#: sys-utils/prlimit.c:82 sys-utils/prlimit.c:86 sys-utils/prlimit.c:90
msgid "bytes"
msgstr "字节"

#: sys-utils/ipcs.c:288
msgid "nattch"
msgstr "连接数"

#: sys-utils/ipcs.c:288
msgid "status"
msgstr "状态"

#: sys-utils/ipcs.c:312 sys-utils/ipcs.c:314 sys-utils/ipcs.c:316
#: sys-utils/ipcs.c:430 sys-utils/ipcs.c:432 sys-utils/ipcs.c:538
#: sys-utils/ipcs.c:540 sys-utils/ipcs.c:542 sys-utils/ipcs.c:596
#: sys-utils/ipcs.c:598 sys-utils/ipcs.c:627 sys-utils/ipcs.c:629
#: sys-utils/ipcs.c:631 sys-utils/ipcs.c:655
msgid "Not set"
msgstr "未设置"

#: sys-utils/ipcs.c:342 sys-utils/lsipc.c:987 sys-utils/lsipc.c:993
msgid "dest"
msgstr "目标"

#: sys-utils/ipcs.c:343 sys-utils/lsipc.c:988 sys-utils/lsipc.c:1001
msgid "locked"
msgstr "已锁定"

#: sys-utils/ipcs.c:363
#, c-format
msgid "unable to fetch semaphore limits\n"
msgstr "无法获取信号量限制\n"

#: sys-utils/ipcs.c:366
#, c-format
msgid "------ Semaphore Limits --------\n"
msgstr "--------- 信号量限制 -----------\n"

#: sys-utils/ipcs.c:367
#, c-format
msgid "max number of arrays = %d\n"
msgstr "最大数组数量 = %d\n"

#: sys-utils/ipcs.c:368
#, c-format
msgid "max semaphores per array = %d\n"
msgstr "每个数组的最大信号量数目 = %d\n"

#: sys-utils/ipcs.c:369
#, c-format
msgid "max semaphores system wide = %d\n"
msgstr "系统最大信号量数 = %d\n"

#: sys-utils/ipcs.c:370
#, c-format
msgid "max ops per semop call = %d\n"
msgstr "每次信号量调用最大操作数 = %d\n"

#: sys-utils/ipcs.c:371
#, c-format
msgid "semaphore max value = %u\n"
msgstr "信号量最大值=%u\n"

#: sys-utils/ipcs.c:380
#, c-format
msgid "kernel not configured for semaphores\n"
msgstr "内核未做信号量的相关配置\n"

#: sys-utils/ipcs.c:383
#, c-format
msgid "------ Semaphore Status --------\n"
msgstr "--------- 信号量状态 -----------\n"

#: sys-utils/ipcs.c:384
#, c-format
msgid "used arrays = %d\n"
msgstr "已使用数组 = %d\n"

#: sys-utils/ipcs.c:385
#, c-format
msgid "allocated semaphores = %d\n"
msgstr "已分配信号量数 = %d\n"

#: sys-utils/ipcs.c:390
#, c-format
msgid "------ Semaphore Arrays Creators/Owners --------\n"
msgstr "----------- 信号量数组创建者/拥有者 ------------\n"

#: sys-utils/ipcs.c:392 sys-utils/ipcs.c:398 sys-utils/ipcs.c:407
msgid "semid"
msgstr "semid"

#: sys-utils/ipcs.c:396
#, c-format
msgid "------ Semaphore Operation/Change Times --------\n"
msgstr "------------ 信号量 操作/更改 时间 -------------\n"

#: sys-utils/ipcs.c:398
msgid "last-op"
msgstr "上一操作"

#: sys-utils/ipcs.c:398
msgid "last-changed"
msgstr "上次更改"

#: sys-utils/ipcs.c:405
#, c-format
msgid "------ Semaphore Arrays --------\n"
msgstr "--------- 信号量数组 -----------\n"

#: sys-utils/ipcs.c:407
msgid "nsems"
msgstr "nsems"

#: sys-utils/ipcs.c:465
#, c-format
msgid "unable to fetch message limits\n"
msgstr "无法获取消息限制\n"

#: sys-utils/ipcs.c:468
#, c-format
msgid "------ Messages Limits --------\n"
msgstr "---------- 消息限制 -----------\n"

#: sys-utils/ipcs.c:469
#, c-format
msgid "max queues system wide = %d\n"
msgstr "系统最大队列数量 = %d\n"

#: sys-utils/ipcs.c:471
msgid "max size of message"
msgstr "最大消息尺寸"

#: sys-utils/ipcs.c:473
msgid "default max size of queue"
msgstr "默认的队列最大尺寸"

#: sys-utils/ipcs.c:480
#, c-format
msgid "kernel not configured for message queues\n"
msgstr "内核未做消息的相关配置\n"

#: sys-utils/ipcs.c:483
#, c-format
msgid "------ Messages Status --------\n"
msgstr "---------- 消息状态 -----------\n"

#: sys-utils/ipcs.c:485
#, c-format
msgid "allocated queues = %d\n"
msgstr "已分配队列数 = %d\n"

#: sys-utils/ipcs.c:486
#, c-format
msgid "used headers = %d\n"
msgstr "已用消息头(header)数 = %d\n"

#: sys-utils/ipcs.c:488
msgid "used space"
msgstr "已用空间"

#: sys-utils/ipcs.c:489
msgid " bytes\n"
msgstr " 字节\n"

#: sys-utils/ipcs.c:493
#, c-format
msgid "------ Message Queues Creators/Owners --------\n"
msgstr "---------- 消息队列 创建者/拥有者 ------------\n"

#: sys-utils/ipcs.c:495 sys-utils/ipcs.c:501 sys-utils/ipcs.c:507
#: sys-utils/ipcs.c:513
msgid "msqid"
msgstr "msqid"

#: sys-utils/ipcs.c:499
#, c-format
msgid "------ Message Queues Send/Recv/Change Times --------\n"
msgstr "----------- 消息队列 发送/接收/更改 时间 ------------\n"

#: sys-utils/ipcs.c:501
msgid "send"
msgstr "发送"

#: sys-utils/ipcs.c:501
msgid "recv"
msgstr "接收"

#: sys-utils/ipcs.c:501
msgid "change"
msgstr "更改"

#: sys-utils/ipcs.c:505
#, c-format
msgid "------ Message Queues PIDs --------\n"
msgstr "--------- 消息队列 PID -----------\n"

#: sys-utils/ipcs.c:507
msgid "lspid"
msgstr "lspid"

#: sys-utils/ipcs.c:507
msgid "lrpid"
msgstr "lrpid"

#: sys-utils/ipcs.c:511
#, c-format
msgid "------ Message Queues --------\n"
msgstr "--------- 消息队列 -----------\n"

#: sys-utils/ipcs.c:514
msgid "used-bytes"
msgstr "已用字节数"

#: sys-utils/ipcs.c:515
msgid "messages"
msgstr "消息"

#: sys-utils/ipcs.c:580 sys-utils/ipcs.c:610 sys-utils/ipcs.c:643
#: sys-utils/lsipc.c:537 sys-utils/lsipc.c:729 sys-utils/lsipc.c:889
#, c-format
msgid "id %d not found"
msgstr "找不到 id %d"

#: sys-utils/ipcs.c:584
#, c-format
msgid ""
"\n"
"Shared memory Segment shmid=%d\n"
msgstr ""
"\n"
"共享内存段 shmid=%d\n"

#: sys-utils/ipcs.c:585
#, c-format
msgid "uid=%u\tgid=%u\tcuid=%u\tcgid=%u\n"
msgstr "uid=%u\tgid=%u\tcuid=%u\tcgid=%u\n"

#: sys-utils/ipcs.c:588
#, c-format
msgid "mode=%#o\taccess_perms=%#o\n"
msgstr "模式=%#o\t访问权限=%#o\n"

#: sys-utils/ipcs.c:590
msgid "size="
msgstr "大小="

#: sys-utils/ipcs.c:590
msgid "bytes="
msgstr "字节数="

#: sys-utils/ipcs.c:592
#, c-format
msgid "lpid=%u\tcpid=%u\tnattch=%jd\n"
msgstr "lpid=%u\tcpid=%u\tnattch=%jd\n"

#: sys-utils/ipcs.c:595
#, c-format
msgid "att_time=%-26.24s\n"
msgstr "附加时间=%-26.24s\n"

#: sys-utils/ipcs.c:597
#, c-format
msgid "det_time=%-26.24s\n"
msgstr "脱离时间=%-26.24s\n"

#: sys-utils/ipcs.c:599 sys-utils/ipcs.c:630
#, c-format
msgid "change_time=%-26.24s\n"
msgstr "更改时间=%-26.24s\n"

#: sys-utils/ipcs.c:614
#, c-format
msgid ""
"\n"
"Message Queue msqid=%d\n"
msgstr ""
"\n"
"消息队列 msqid=%d\n"

#: sys-utils/ipcs.c:615
#, c-format
msgid "uid=%u\tgid=%u\tcuid=%u\tcgid=%u\tmode=%#o\n"
msgstr "uid=%u\tgid=%u\tcuid=%u\tcgid=%u\t模式=%#o\n"

#: sys-utils/ipcs.c:619
msgid "csize="
msgstr "csize="

#: sys-utils/ipcs.c:619
msgid "cbytes="
msgstr "cbytes="

#: sys-utils/ipcs.c:621
msgid "qsize="
msgstr "qsize="

#: sys-utils/ipcs.c:621
msgid "qbytes="
msgstr "qbytes="

#: sys-utils/ipcs.c:626
#, c-format
msgid "send_time=%-26.24s\n"
msgstr "发送时间=%-26.24s\n"

#: sys-utils/ipcs.c:628
#, c-format
msgid "rcv_time=%-26.24s\n"
msgstr "接收时间=%-26.24s\n"

#: sys-utils/ipcs.c:647
#, c-format
msgid ""
"\n"
"Semaphore Array semid=%d\n"
msgstr ""
"\n"
"信号量数组 semid=%d\n"

#: sys-utils/ipcs.c:648
#, c-format
msgid "uid=%u\t gid=%u\t cuid=%u\t cgid=%u\n"
msgstr "uid=%u\t gid=%u\t cuid=%u\t cgid=%u\n"

#: sys-utils/ipcs.c:651
#, c-format
msgid "mode=%#o, access_perms=%#o\n"
msgstr "模式=%#o，访问权限=%#o\n"

#: sys-utils/ipcs.c:653
#, c-format
msgid "nsems = %ju\n"
msgstr "nsems = %ju\n"

#: sys-utils/ipcs.c:654
#, c-format
msgid "otime = %-26.24s\n"
msgstr "otime = %-26.24s\n"

#: sys-utils/ipcs.c:656
#, c-format
msgid "ctime = %-26.24s\n"
msgstr "ctime = %-26.24s\n"

#: sys-utils/ipcs.c:659
msgid "semnum"
msgstr "semnum"

#: sys-utils/ipcs.c:659
msgid "value"
msgstr "值"

#: sys-utils/ipcs.c:659
msgid "ncount"
msgstr "ncount"

#: sys-utils/ipcs.c:659
msgid "zcount"
msgstr "zcount"

#: sys-utils/ipcs.c:659
msgid "pid"
msgstr "pid"

#: sys-utils/ipcutils.c:230 sys-utils/ipcutils.c:234 sys-utils/ipcutils.c:238
#: sys-utils/ipcutils.c:242
#, c-format
msgid "%s failed"
msgstr "%s 失败"

#: sys-utils/ipcutils.c:503
#, c-format
msgid "%s (bytes) = "
msgstr "%s (字节) = "

#: sys-utils/ipcutils.c:505
#, c-format
msgid "%s (kbytes) = "
msgstr "%s (千字节) = "

#: sys-utils/ldattach.c:184
msgid "invalid iflag"
msgstr "无效的 iflag"

#: sys-utils/ldattach.c:200
#, c-format
msgid " %s [options] <ldisc> <device>\n"
msgstr " %s [选项] <线路规则> <设备>\n"

#: sys-utils/ldattach.c:203
msgid "Attach a line discipline to a serial line.\n"
msgstr "向串口线附加一条线路规则。\n"

#: sys-utils/ldattach.c:206
msgid " -d, --debug             print verbose messages to stderr\n"
msgstr " -d, --debug             向标准错误打印详尽消息\n"

#: sys-utils/ldattach.c:207
msgid " -s, --speed <value>     set serial line speed\n"
msgstr " -s, --speed <值>        设置串口线速度\n"

#: sys-utils/ldattach.c:208
msgid " -c, --intro-command <string> intro sent before ldattach\n"
msgstr " -c, --intro-command <字符串> 先发送 intro 后发送 ldattach\n"

#: sys-utils/ldattach.c:209
msgid " -p, --pause <seconds>   pause between intro and ldattach\n"
msgstr " -p, --pause <秒数>   在 intro 和 ldattach 之间暂停\n"

#: sys-utils/ldattach.c:210
msgid " -7, --sevenbits         set character size to 7 bits\n"
msgstr " -7, --sevenbits         字节大小设为 7 位\n"

#: sys-utils/ldattach.c:211
msgid " -8, --eightbits         set character size to 8 bits\n"
msgstr " -8, --eightbits         字节大小设为 8 位\n"

#: sys-utils/ldattach.c:212
msgid " -n, --noparity          set parity to none\n"
msgstr " -n, --noparity          设为无校验位\n"

#: sys-utils/ldattach.c:213
msgid " -e, --evenparity        set parity to even\n"
msgstr " -e, --evenparity        设为奇检验\n"

#: sys-utils/ldattach.c:214
msgid " -o, --oddparity         set parity to odd\n"
msgstr " -o, --oddparity         设为偶检验\n"

#: sys-utils/ldattach.c:215
msgid " -1, --onestopbit        set stop bits to one\n"
msgstr " -1, --onestopbit        停止位设为 1\n"

#: sys-utils/ldattach.c:216
msgid " -2, --twostopbits       set stop bits to two\n"
msgstr " -2, --twostopbits       停止位设为 2\n"

#: sys-utils/ldattach.c:217
msgid " -i, --iflag [-]<iflag>  set input mode flag\n"
msgstr " -i, --iflag [-]<iflag>  设置输入模式标志\n"

#: sys-utils/ldattach.c:222
msgid ""
"\n"
"Known <ldisc> names:\n"
msgstr ""
"\n"
"已知<线路规则>名称：\n"

#: sys-utils/ldattach.c:226
msgid ""
"\n"
"Known <iflag> names:\n"
msgstr ""
"\n"
"已知<iflag>名称：\n"

#: sys-utils/ldattach.c:344
msgid "invalid speed argument"
msgstr "无效的 速度 参数"

#: sys-utils/ldattach.c:347
msgid "invalid pause argument"
msgstr "无效的暂停参数"

#: sys-utils/ldattach.c:374
msgid "invalid line discipline argument"
msgstr "无效的 线路规则 参数"

#: sys-utils/ldattach.c:394
#, c-format
msgid "%s is not a serial line"
msgstr "%s 不是串行线"

#: sys-utils/ldattach.c:401
#, c-format
msgid "cannot get terminal attributes for %s"
msgstr "无法获取 %s 的终端属性"

#: sys-utils/ldattach.c:404
#, c-format
msgid "speed %d unsupported"
msgstr "不支持速度 %d"

#: sys-utils/ldattach.c:453
#, c-format
msgid "cannot set terminal attributes for %s"
msgstr "无法设置 %s 的终端属性"

#: sys-utils/ldattach.c:463
#, c-format
msgid "cannot write intro command to %s"
msgstr "无法向 %s 写入 intro 命令"

#: sys-utils/ldattach.c:473
msgid "cannot set line discipline"
msgstr "无法设置行规则"

#: sys-utils/ldattach.c:483
msgid "cannot daemonize"
msgstr "无法转为守护进程"

#: sys-utils/losetup.c:70
msgid "autoclear flag set"
msgstr "已设置 自动清除 标志"

#: sys-utils/losetup.c:71
msgid "device backing file"
msgstr "设备后备文件"

#: sys-utils/losetup.c:72
msgid "backing file inode number"
msgstr "后备文件 inode 号"

#: sys-utils/losetup.c:73
msgid "backing file major:minor device number"
msgstr "后备文件 主:次 设备号"

#: sys-utils/losetup.c:74
msgid "loop device name"
msgstr "回环设备名"

#: sys-utils/losetup.c:75
msgid "offset from the beginning"
msgstr "起始位置偏移"

#: sys-utils/losetup.c:76
msgid "partscan flag set"
msgstr "已设置 partscan 标志"

#: sys-utils/losetup.c:78
msgid "size limit of the file in bytes"
msgstr "文件的大小限制(字节数)"

#: sys-utils/losetup.c:79
msgid "loop device major:minor number"
msgstr "回环设备 主:次 设备号"

#: sys-utils/losetup.c:80
msgid "access backing file with direct-io"
msgstr "通过直接 IO 访问后备文件"

#: sys-utils/losetup.c:81
#, fuzzy
msgid "logical sector size in bytes"
msgstr "逻辑扇区大小"

#: sys-utils/losetup.c:138 sys-utils/losetup.c:150
#, c-format
msgid ", offset %ju"
msgstr "，偏移 %ju"

#: sys-utils/losetup.c:141 sys-utils/losetup.c:153
#, c-format
msgid ", sizelimit %ju"
msgstr "，大小限制 %ju"

#: sys-utils/losetup.c:161
#, c-format
msgid ", encryption %s (type %u)"
msgstr "，加密 %s(类型 %u)"

#: sys-utils/losetup.c:202
#, c-format
msgid "%s: detach failed"
msgstr "%s：断开失败"

#: sys-utils/losetup.c:393
#, c-format
msgid ""
" %1$s [options] [<loopdev>]\n"
" %1$s [options] -f | <loopdev> <file>\n"
msgstr ""
" %1$s [选项] [<回环设备>]\n"
" %1$s [选项] -f | <回环设备> <文件>\n"

#: sys-utils/losetup.c:398
msgid "Set up and control loop devices.\n"
msgstr "设置和控制回环设备。\n"

#: sys-utils/losetup.c:402
msgid " -a, --all                     list all used devices\n"
msgstr " -a, --all                     列出所有使用的设备\n"

#: sys-utils/losetup.c:403
msgid " -d, --detach <loopdev>...     detach one or more devices\n"
msgstr " -d, --detach <回环设备>...    断开一台或多台设备\n"

#: sys-utils/losetup.c:404
msgid " -D, --detach-all              detach all used devices\n"
msgstr " -D, --detach-all              断开所有使用的设备\n"

#: sys-utils/losetup.c:405
msgid " -f, --find                    find first unused device\n"
msgstr " -f, --find                    查找第一个未使用的设备\n"

#: sys-utils/losetup.c:406
msgid " -c, --set-capacity <loopdev>  resize the device\n"
msgstr " -c, --set-capacity <回环设备> 改变设备容量\n"

#: sys-utils/losetup.c:407
msgid " -j, --associated <file>       list all devices associated with <file>\n"
msgstr " -j, --associated <文件>       列出所有与 <文件> 相关的设备\n"

#: sys-utils/losetup.c:408
msgid " -L, --nooverlap               avoid possible conflict between devices\n"
msgstr " -L, --nooverlap               避免设备间的潜在冲突\n"

#: sys-utils/losetup.c:412
msgid " -o, --offset <num>            start at offset <num> into file\n"
msgstr " -o, --offset <数字>           在文件偏移量 <数字> 处开始\n"

#: sys-utils/losetup.c:413
msgid "     --sizelimit <num>         device is limited to <num> bytes of the file\n"
msgstr "     --sizelimit <数字>        设备限制为了文件的<数字>个字节\n"

#: sys-utils/losetup.c:414
#, fuzzy
msgid " -b  --sector-size <num>       set the logical sector size to <num>\n"
msgstr " -b, --sectors-size <大小>     显示扇区计数和大小\n"

#: sys-utils/losetup.c:415
msgid " -P, --partscan                create a partitioned loop device\n"
msgstr " -P, --partscan                创建带分区的回环设备\n"

#: sys-utils/losetup.c:416
msgid " -r, --read-only               set up a read-only loop device\n"
msgstr " -r, --read-only               创建只读的回环设备\n"

#: sys-utils/losetup.c:417
msgid "     --direct-io[=<on|off>]    open backing file with O_DIRECT\n"
msgstr "     --direct-io[=<on|off>]    通过 O_DIRECT 打开后备文件\n"

#: sys-utils/losetup.c:418
msgid "     --show                    print device name after setup (with -f)\n"
msgstr "     --show                    设置后打印设备名(加 -f 选项)\n"

#: sys-utils/losetup.c:419
msgid " -v, --verbose                 verbose mode\n"
msgstr " -v, --verbose                 详尽模式\n"

#: sys-utils/losetup.c:423
msgid " -J, --json                    use JSON --list output format\n"
msgstr " -J, --json                    使用 JSON --list 输出格式\n"

#: sys-utils/losetup.c:424
msgid " -l, --list                    list info about all or specified (default)\n"
msgstr " -l, --list                    列出所有或指定的信息(默认)\n"

#: sys-utils/losetup.c:425
msgid " -n, --noheadings              don't print headings for --list output\n"
msgstr " -n, --noheadings              --list 输出时不打印标题\n"

#: sys-utils/losetup.c:426
msgid " -O, --output <cols>           specify columns to output for --list\n"
msgstr " -O, --output <列>           指定 --list 选项要输出的列\n"

#: sys-utils/losetup.c:427
msgid "     --raw                     use raw --list output format\n"
msgstr "     --raw                     使用原生 --list 输出格式\n"

#: sys-utils/losetup.c:452
#, c-format
msgid "%s: Warning: file is smaller than 512 bytes; the loop device may be useless or invisible for system tools."
msgstr "%s：警告，文件小于 512 个字节，回环设备可能无用或在系统工具中看不到。"

#: sys-utils/losetup.c:456
#, c-format
msgid "%s: Warning: file does not fit into a 512-byte sector; the end of the file will be ignored."
msgstr "%s：警告，文件未对齐 512 字节扇区，其末尾将被忽略。"

#: sys-utils/losetup.c:477 sys-utils/losetup.c:529
#, c-format
msgid "%s: overlapping loop device exists"
msgstr "%s: 重叠的回环设备已存在"

#: sys-utils/losetup.c:488
#, c-format
msgid "%s: overlapping read-only loop device exists"
msgstr "%s: 存在重叠的只读回环设备"

#: sys-utils/losetup.c:495
#, c-format
msgid "%s: overlapping encrypted loop device exists"
msgstr "%s：存在重叠的加密回环设备"

#: sys-utils/losetup.c:501
#, c-format
msgid "%s: failed to re-use loop device"
msgstr "%s︰ 未能重新使用回环设备"

#: sys-utils/losetup.c:507
msgid "failed to inspect loop devices"
msgstr "审查回环设备失败"

#: sys-utils/losetup.c:530
#, c-format
msgid "%s: failed to check for conflicting loop devices"
msgstr "%s︰ 检查冲突的循环设备失败"

#: sys-utils/losetup.c:542 sys-utils/losetup.c:847
msgid "cannot find an unused loop device"
msgstr "找不到未使用的回环设备"

#: sys-utils/losetup.c:552
#, c-format
msgid "%s: failed to use backing file"
msgstr "%s：使用后备文件失败"

#: sys-utils/losetup.c:643
#, fuzzy
msgid "failed to parse logical block size"
msgstr "解析大小失败"

#: sys-utils/losetup.c:649 sys-utils/losetup.c:659 sys-utils/losetup.c:774
#: sys-utils/losetup.c:788 sys-utils/losetup.c:827
#, c-format
msgid "%s: failed to use device"
msgstr "%s：使用设备失败"

#: sys-utils/losetup.c:785
msgid "no loop device specified"
msgstr "未指定回环设备"

#: sys-utils/losetup.c:800
#, c-format
msgid "the options %s are allowed during loop device setup only"
msgstr "选项 %s 只允许在设置回环设备时使用"

#: sys-utils/losetup.c:805
msgid "the option --offset is not allowed in this context"
msgstr "此环境下不允许使用 --offset 选项"

#: sys-utils/losetup.c:868
#, c-format
msgid "%s: set capacity failed"
msgstr "%s：设置容量失败"

#: sys-utils/losetup.c:877
#, c-format
msgid "%s: set direct io failed"
msgstr "%s︰ 设置直接 io 失败"

#: sys-utils/losetup.c:883
#, fuzzy, c-format
msgid "%s: set logical block size failed"
msgstr "%s：获取大小失败"

#: sys-utils/lscpu.c:95
msgid "none"
msgstr "无"

#: sys-utils/lscpu.c:96
msgid "para"
msgstr "半"

#: sys-utils/lscpu.c:97
msgid "full"
msgstr "完全"

#: sys-utils/lscpu.c:98
msgid "container"
msgstr "容器"

#: sys-utils/lscpu.c:141
msgid "horizontal"
msgstr "水平"

#: sys-utils/lscpu.c:142
msgid "vertical"
msgstr "竖直"

#: sys-utils/lscpu.c:194
msgid "logical CPU number"
msgstr "逻辑 CPU 数量"

#: sys-utils/lscpu.c:195
msgid "logical core number"
msgstr "逻辑核心数量"

#: sys-utils/lscpu.c:196
msgid "logical socket number"
msgstr "逻辑(CPU)座数量"

#: sys-utils/lscpu.c:197
msgid "logical NUMA node number"
msgstr "逻辑 NUMA 节点数量"

#: sys-utils/lscpu.c:198
msgid "logical book number"
msgstr "逻辑 book 数"

#: sys-utils/lscpu.c:199
msgid "logical drawer number"
msgstr "逻辑抽屉号"

#: sys-utils/lscpu.c:200
msgid "shows how caches are shared between CPUs"
msgstr "显示 CPU 间是如何共享缓存的"

#: sys-utils/lscpu.c:201
msgid "CPU dispatching mode on virtual hardware"
msgstr "虚拟硬件上的 CPU 调度模式"

#: sys-utils/lscpu.c:202
msgid "physical address of a CPU"
msgstr "CPU 的物理地址"

#: sys-utils/lscpu.c:203
msgid "shows if the hypervisor has allocated the CPU"
msgstr "显示超级监督(hypervisor)是否分配了 CPU"

#: sys-utils/lscpu.c:204
msgid "shows if Linux currently makes use of the CPU"
msgstr "显示 Linux 当前是否在使用该 CPU"

#: sys-utils/lscpu.c:205
msgid "shows the maximum MHz of the CPU"
msgstr "显示 CPU 的最大 MHz"

#: sys-utils/lscpu.c:206
msgid "shows the minimum MHz of the CPU"
msgstr "显示 CPU 的最小 MHz"

#: sys-utils/lscpu.c:399
msgid "error: uname failed"
msgstr "错误：uname 失败"

#: sys-utils/lscpu.c:486
#, c-format
msgid "failed to determine number of CPUs: %s"
msgstr "确定 CPU 数 失败：%s"

#: sys-utils/lscpu.c:748
#, fuzzy
msgid "cannot restore signal handler"
msgstr "无法设置信号处理函数"

#: sys-utils/lscpu.c:1307
msgid "Failed to extract the node number"
msgstr "提取节点号失败"

#: sys-utils/lscpu.c:1433 sys-utils/lscpu.c:1443
msgid "Y"
msgstr "Y"

#: sys-utils/lscpu.c:1433 sys-utils/lscpu.c:1443
msgid "N"
msgstr "N"

#: sys-utils/lscpu.c:1527
#, c-format
msgid ""
"# The following is the parsable format, which can be fed to other\n"
"# programs. Each different item in every column has an unique ID\n"
"# starting from zero.\n"
msgstr ""
"# 以下是可解析格式，可以输给其他程序。每列中的各个不同项有一个惟一\n"
"# 的从 0 开始的 ID。\n"

#: sys-utils/lscpu.c:1724
msgid "Architecture:"
msgstr "架构："

#: sys-utils/lscpu.c:1737
msgid "CPU op-mode(s):"
msgstr "CPU 运行模式："

#: sys-utils/lscpu.c:1740 sys-utils/lscpu.c:1742
msgid "Byte Order:"
msgstr "字节序："

#: sys-utils/lscpu.c:1744
msgid "CPU(s):"
msgstr "CPU:"

#: sys-utils/lscpu.c:1747
msgid "On-line CPU(s) mask:"
msgstr "在线 CPU 掩码："

#: sys-utils/lscpu.c:1748
msgid "On-line CPU(s) list:"
msgstr "在线 CPU 列表："

#: sys-utils/lscpu.c:1767
msgid "Off-line CPU(s) mask:"
msgstr "离线 CPU 掩码："

#: sys-utils/lscpu.c:1768
msgid "Off-line CPU(s) list:"
msgstr "离线 CPU 列表："

#: sys-utils/lscpu.c:1803
msgid "Thread(s) per core:"
msgstr "每个核的线程数："

#: sys-utils/lscpu.c:1805
msgid "Core(s) per socket:"
msgstr "每个座的核数："

#: sys-utils/lscpu.c:1808
msgid "Socket(s) per book:"
msgstr "每个 book 的座数："

#: sys-utils/lscpu.c:1811
msgid "Book(s) per drawer:"
msgstr "每个抽屉里的 Book 数︰"

#: sys-utils/lscpu.c:1813
msgid "Drawer(s):"
msgstr "抽屉："

#: sys-utils/lscpu.c:1815
msgid "Book(s):"
msgstr "Book："

#: sys-utils/lscpu.c:1818
msgid "Socket(s):"
msgstr "座："

#: sys-utils/lscpu.c:1822
msgid "NUMA node(s):"
msgstr "NUMA 节点："

#: sys-utils/lscpu.c:1824
msgid "Vendor ID:"
msgstr "厂商 ID："

#: sys-utils/lscpu.c:1826
msgid "Machine type:"
msgstr "机器类型︰"

#: sys-utils/lscpu.c:1828
msgid "CPU family:"
msgstr "CPU 系列："

#: sys-utils/lscpu.c:1830
msgid "Model:"
msgstr "型号："

#: sys-utils/lscpu.c:1832
msgid "Model name:"
msgstr "型号名称："

#: sys-utils/lscpu.c:1834
msgid "Stepping:"
msgstr "步进："

#: sys-utils/lscpu.c:1836
msgid "CPU MHz:"
msgstr "CPU MHz："

#: sys-utils/lscpu.c:1838
msgid "CPU dynamic MHz:"
msgstr "CPU 动态 MHz:"

#: sys-utils/lscpu.c:1840
msgid "CPU static MHz:"
msgstr "CPU 静态 MHz:"

#: sys-utils/lscpu.c:1842
msgid "CPU max MHz:"
msgstr "CPU 最大 MHz："

#: sys-utils/lscpu.c:1844
msgid "CPU min MHz:"
msgstr "CPU 最小 MHz："

#: sys-utils/lscpu.c:1846
msgid "BogoMIPS:"
msgstr "BogoMIPS："

#: sys-utils/lscpu.c:1849 sys-utils/lscpu.c:1851
msgid "Virtualization:"
msgstr "虚拟化："

#: sys-utils/lscpu.c:1854
msgid "Hypervisor:"
msgstr "超管理器："

#: sys-utils/lscpu.c:1856
msgid "Hypervisor vendor:"
msgstr "超管理器厂商："

#: sys-utils/lscpu.c:1857
msgid "Virtualization type:"
msgstr "虚拟化类型："

#: sys-utils/lscpu.c:1860
msgid "Dispatching mode:"
msgstr "分派模式："

#: sys-utils/lscpu.c:1864 sys-utils/lscpu.c:1871
#, c-format
msgid "%s cache:"
msgstr "%s 缓存："

#: sys-utils/lscpu.c:1877
#, c-format
msgid "NUMA node%d CPU(s):"
msgstr "NUMA 节点%d CPU："

#: sys-utils/lscpu.c:1882
msgid "Physical sockets:"
msgstr "物理套接字︰"

#: sys-utils/lscpu.c:1883
msgid "Physical chips:"
msgstr "物理芯片︰"

#: sys-utils/lscpu.c:1884
msgid "Physical cores/chip:"
msgstr "物理核心/芯片︰"

#: sys-utils/lscpu.c:1888
msgid "Flags:"
msgstr "标记："

#: sys-utils/lscpu.c:1903
msgid "Display information about the CPU architecture.\n"
msgstr "显示 CPU 架构信息。\n"

#: sys-utils/lscpu.c:1906
msgid " -a, --all               print both online and offline CPUs (default for -e)\n"
msgstr " -a, --all               同时打印在线和离线 CPU (-e 选项默认值)\n"

#: sys-utils/lscpu.c:1907
msgid " -b, --online            print online CPUs only (default for -p)\n"
msgstr " -b, --online            只打印在线 CPU (-p 选项默认值)\n"

#: sys-utils/lscpu.c:1908
msgid " -c, --offline           print offline CPUs only\n"
msgstr " -c, --offline           只打印离线 CPU\n"

#: sys-utils/lscpu.c:1909
#, fuzzy
msgid " -J, --json              use JSON for default or extended format\n"
msgstr " -J, --json              使用 JSON 输出格式\n"

#: sys-utils/lscpu.c:1910
msgid " -e, --extended[=<list>] print out an extended readable format\n"
msgstr " -e, --extended[=<列表>] 打印扩展的可读格式\n"

#: sys-utils/lscpu.c:1911
msgid " -p, --parse[=<list>]    print out a parsable format\n"
msgstr " -p, --parse[=<列表>]    打印可解析格式\n"

#: sys-utils/lscpu.c:1912
msgid " -s, --sysroot <dir>     use specified directory as system root\n"
msgstr " -s, --sysroot <目录>    以指定目录作为系统根目录\n"

#: sys-utils/lscpu.c:1913
msgid " -x, --hex               print hexadecimal masks rather than lists of CPUs\n"
msgstr " -x, --hex               打印十六进制掩码而非 CPU 列表\n"

#: sys-utils/lscpu.c:1914
msgid " -y, --physical          print physical instead of logical IDs\n"
msgstr " -y, --physical          打印物理 ID 而非逻辑 ID\n"

#: sys-utils/lscpu.c:1999 sys-utils/lsmem.c:601
#, fuzzy, c-format
msgid "invalid argument to %s"
msgstr "无效参数：%s"

#: sys-utils/lscpu.c:2018
#, c-format
msgid "%s: options --all, --online and --offline may only be used with options --extended or --parse.\n"
msgstr "%s：--all、--online 和 --offline 选项只能与 --extended 或 --parse 选项一起使用。\n"

#: sys-utils/lsipc.c:149
msgid "Resource key"
msgstr "资源键"

#: sys-utils/lsipc.c:149
msgid "Key"
msgstr "键"

#: sys-utils/lsipc.c:150
msgid "Resource ID"
msgstr "资源 ID"

#: sys-utils/lsipc.c:150
msgid "ID"
msgstr "ID"

#: sys-utils/lsipc.c:151
msgid "Owner's username or UID"
msgstr "拥有者的用户名或 UID"

#: sys-utils/lsipc.c:151
msgid "Owner"
msgstr "拥有者"

#: sys-utils/lsipc.c:152
msgid "Permissions"
msgstr "权限"

#: sys-utils/lsipc.c:153
msgid "Creator UID"
msgstr " 创建者 UID"

#: sys-utils/lsipc.c:154
msgid "Creator user"
msgstr " 创建者 用户"

#: sys-utils/lsipc.c:155
msgid "Creator GID"
msgstr "创建者 GID"

#: sys-utils/lsipc.c:156
msgid "Creator group"
msgstr "创建者组"

#: sys-utils/lsipc.c:157
msgid "User ID"
msgstr "用户 ID"

#: sys-utils/lsipc.c:157
msgid "UID"
msgstr "UID"

#: sys-utils/lsipc.c:158
msgid "User name"
msgstr "用户名"

#: sys-utils/lsipc.c:159
msgid "Group ID"
msgstr " 组 ID"

#: sys-utils/lsipc.c:159
msgid "GID"
msgstr "GID"

#: sys-utils/lsipc.c:160
msgid "Group name"
msgstr "组名"

#: sys-utils/lsipc.c:161
msgid "Time of the last change"
msgstr "上次更改时间"

#: sys-utils/lsipc.c:161
msgid "Last change"
msgstr "上次更改"

#: sys-utils/lsipc.c:164
msgid "Bytes used"
msgstr "已用字节数"

#: sys-utils/lsipc.c:165
msgid "Number of messages"
msgstr "消息数"

#: sys-utils/lsipc.c:165
msgid "Messages"
msgstr "消息"

#: sys-utils/lsipc.c:166
msgid "Time of last msg sent"
msgstr "上次发消息的时间"

#: sys-utils/lsipc.c:166
msgid "Msg sent"
msgstr " 消息已发送"

#: sys-utils/lsipc.c:167
msgid "Time of last msg received"
msgstr "收到上条消息的时间"

#: sys-utils/lsipc.c:167
msgid "Msg received"
msgstr "消息已收到"

#: sys-utils/lsipc.c:168
msgid "PID of the last msg sender"
msgstr "上条消息发送者的 PID"

#: sys-utils/lsipc.c:168
msgid "Msg sender"
msgstr " 消息发送者"

#: sys-utils/lsipc.c:169
msgid "PID of the last msg receiver"
msgstr "上条消息接收者的 PID"

#: sys-utils/lsipc.c:169
msgid "Msg receiver"
msgstr "消息接收者"

#: sys-utils/lsipc.c:172
msgid "Segment size"
msgstr "片段大小"

#: sys-utils/lsipc.c:173
msgid "Number of attached processes"
msgstr "附加的进程数"

#: sys-utils/lsipc.c:173
msgid "Attached processes"
msgstr "附加的进程"

#: sys-utils/lsipc.c:174
msgid "Status"
msgstr "状态"

#: sys-utils/lsipc.c:175
msgid "Attach time"
msgstr "附加时间"

#: sys-utils/lsipc.c:176
msgid "Detach time"
msgstr "分离时间"

#: sys-utils/lsipc.c:177
msgid "Creator command line"
msgstr "创建者命令行"

#: sys-utils/lsipc.c:177
msgid "Creator command"
msgstr "创建者命令"

#: sys-utils/lsipc.c:178
msgid "PID of the creator"
msgstr "创建者的 PID"

#: sys-utils/lsipc.c:178
msgid "Creator PID"
msgstr " 创建者 PID"

#: sys-utils/lsipc.c:179
msgid "PID of last user"
msgstr " 上个用户的 PID"

#: sys-utils/lsipc.c:179
msgid "Last user PID"
msgstr "上一用户 PID"

#: sys-utils/lsipc.c:182
msgid "Number of semaphores"
msgstr "信号量个数"

#: sys-utils/lsipc.c:182
msgid "Semaphores"
msgstr "信号量"

#: sys-utils/lsipc.c:183
msgid "Time of the last operation"
msgstr " 上次操作的时间"

#: sys-utils/lsipc.c:183
msgid "Last operation"
msgstr "上次操作"

#: sys-utils/lsipc.c:186
msgid "Resource name"
msgstr "资源名称"

#: sys-utils/lsipc.c:186
msgid "Resource"
msgstr "资源"

#: sys-utils/lsipc.c:187
msgid "Resource description"
msgstr "资源描述"

#: sys-utils/lsipc.c:187
msgid "Description"
msgstr "描述"

#: sys-utils/lsipc.c:188
msgid "Currently used"
msgstr "当前已使用"

#: sys-utils/lsipc.c:188
msgid "Used"
msgstr "已使用"

#: sys-utils/lsipc.c:189
msgid "Currently use percentage"
msgstr "当前使用比例"

#: sys-utils/lsipc.c:189
msgid "Use"
msgstr "使用"

#: sys-utils/lsipc.c:190
msgid "System-wide limit"
msgstr "系统级限制"

#: sys-utils/lsipc.c:190
msgid "Limit"
msgstr "限制"

#: sys-utils/lsipc.c:225
#, c-format
msgid "column %s does not apply to the specified IPC"
msgstr "列 %s 不适用于指定的 IPC"

#: sys-utils/lsipc.c:288
msgid " -g, --global      info about system-wide usage (may be used with -m, -q and -s)\n"
msgstr " -g, --global      有关系统范围使用量的信息(可与 -m, -q 和 -s 共用)\n"

#: sys-utils/lsipc.c:289
msgid " -i, --id <id>     print details on resource identified by <id>\n"
msgstr " -i, --id <id>     打印由<id>标识的资源的详细信息\n"

#: sys-utils/lsipc.c:295
msgid " -b, --bytes              print SIZE in bytes rather than in human readable format\n"
msgstr " -b, --bytes              以字节为打印 SIZE，而非易读格式\n"

#: sys-utils/lsipc.c:296
msgid " -c, --creator            show creator and owner\n"
msgstr " -c, --creator            显示创建者和拥有者\n"

#: sys-utils/lsipc.c:298
msgid " -J, --json               use the JSON output format\n"
msgstr " -J, --json               使用 JSON 输出格式\n"

#: sys-utils/lsipc.c:300
msgid " -l, --list               force list output format (for example with --id)\n"
msgstr " -l, --list               强制以列表格式输出(如与 --id 共用)\n"

#: sys-utils/lsipc.c:302
msgid " -P, --numeric-perms      print numeric permissions (PERMS column)\n"
msgstr " -P, --numeric-perms      打印权限数值(PERMS 列)\n"

#: sys-utils/lsipc.c:304
msgid " -t, --time               show attach, detach and change times\n"
msgstr " -t, --time               显示附加、脱离和更改时间\n"

#: sys-utils/lsipc.c:309
#, c-format
msgid ""
"\n"
"Generic columns:\n"
msgstr ""
"\n"
"常规选项：\n"

#: sys-utils/lsipc.c:313
#, fuzzy, c-format
msgid ""
"\n"
"Shared-memory columns (--shmems):\n"
msgstr ""
"\n"
"共享内存段 shmid=%d\n"

#: sys-utils/lsipc.c:317
#, c-format
msgid ""
"\n"
"Message-queue columns (--queues):\n"
msgstr ""
"\n"
"消息队列 列(queues)：\n"

#: sys-utils/lsipc.c:321
#, c-format
msgid ""
"\n"
"Semaphore columns (--semaphores):\n"
msgstr ""
"\n"
"信号量 列(--semaphores)：\n"

#: sys-utils/lsipc.c:325
#, c-format
msgid ""
"\n"
"Summary columns (--global):\n"
msgstr ""
"\n"
"摘要 列(--global)：\n"

#: sys-utils/lsipc.c:414
#, c-format
msgid ""
"Elements:\n"
"\n"
msgstr ""
"元素：\n"
"\n"

#: sys-utils/lsipc.c:687 sys-utils/lsipc.c:848 sys-utils/lsipc.c:1047
msgid "failed to set data"
msgstr "设置数据失败"

#: sys-utils/lsipc.c:712
msgid "Number of semaphore identifiers"
msgstr "信号量标识符的数量"

#: sys-utils/lsipc.c:713
msgid "Total number of semaphores"
msgstr "信号量的总数"

#: sys-utils/lsipc.c:714
msgid "Max semaphores per semaphore set."
msgstr "每个信号量集的最大信号量数。"

#: sys-utils/lsipc.c:715
msgid "Max number of operations per semop(2)"
msgstr "每个 semop(2) 的最大操作数"

#: sys-utils/lsipc.c:716
msgid "Semaphore max value"
msgstr "信号量的最大值"

#: sys-utils/lsipc.c:873
msgid "Number of message queues"
msgstr "消息队列的数目"

#: sys-utils/lsipc.c:874
msgid "Max size of message (bytes)"
msgstr "消息的最大尺寸(字节)"

#: sys-utils/lsipc.c:875
msgid "Default max size of queue (bytes)"
msgstr "队列的默认最大尺寸(字节)"

#: sys-utils/lsipc.c:989 sys-utils/lsipc.c:1008
msgid "hugetlb"
msgstr "hugetlb"

#: sys-utils/lsipc.c:990 sys-utils/lsipc.c:1015
msgid "noreserve"
msgstr "noreserve"

#: sys-utils/lsipc.c:1072
msgid "Shared memory segments"
msgstr "共享内存段"

#: sys-utils/lsipc.c:1073
msgid "Shared memory pages"
msgstr "共享内存页"

#: sys-utils/lsipc.c:1074
msgid "Max size of shared memory segment (bytes)"
msgstr "共享内存段的最大尺寸(字节)"

#: sys-utils/lsipc.c:1075
msgid "Min size of shared memory segment (bytes)"
msgstr "共享内存段的最小尺寸(字节)"

#: sys-utils/lsipc.c:1145
msgid "failed to parse IPC identifier"
msgstr "解析 IPC 标识符失败"

#: sys-utils/lsipc.c:1239
msgid "--global is mutually exclusive with --creator, --id and --time"
msgstr "--global 与 --creator, --id 和 --time 互斥"

#: sys-utils/lsmem.c:128
msgid "start and end address of the memory range"
msgstr ""

#: sys-utils/lsmem.c:129
#, fuzzy
msgid "size of the memory range"
msgstr "磁盘容量"

#: sys-utils/lsmem.c:130
msgid "online status of the memory range"
msgstr ""

#: sys-utils/lsmem.c:131
#, fuzzy
msgid "memory is removable"
msgstr " 可移动"

#: sys-utils/lsmem.c:132
msgid "memory block number or blocks range"
msgstr ""

#: sys-utils/lsmem.c:133
#, fuzzy
msgid "numa node of memory"
msgstr "内存不足"

#: sys-utils/lsmem.c:134
#, fuzzy
msgid "valid zones for the memory range"
msgstr "磁盘容量"

#: sys-utils/lsmem.c:261
#, fuzzy
msgid "online"
msgstr "，在线"

#: sys-utils/lsmem.c:262
#, fuzzy
msgid "offline"
msgstr "，在线"

#: sys-utils/lsmem.c:263
msgid "on->off"
msgstr ""

#: sys-utils/lsmem.c:322 sys-utils/lsmem.c:329
#, fuzzy
msgid "Memory block size:"
msgstr "获得块大小"

#: sys-utils/lsmem.c:323 sys-utils/lsmem.c:333
#, fuzzy
msgid "Total online memory:"
msgstr "最大总共享内存"

#: sys-utils/lsmem.c:324 sys-utils/lsmem.c:337
msgid "Total offline memory:"
msgstr ""

#: sys-utils/lsmem.c:351
#, fuzzy, c-format
msgid "Failed to open %s"
msgstr "解析 %s 失败"

#: sys-utils/lsmem.c:472
#, fuzzy
msgid "This system does not support memory blocks"
msgstr "该系统不支持重新扫描 CPU"

#: sys-utils/lsmem.c:499
msgid "List the ranges of available memory with their online status.\n"
msgstr ""

#: sys-utils/lsmem.c:504
#, fuzzy
msgid " -a, --all            list each individual memory block\n"
msgstr " -a, --all            打印所有设备\n"

#: sys-utils/lsmem.c:509
#, fuzzy
msgid " -S, --split <list>   split ranges by specified columns\n"
msgstr " -o, --output <列表>       输出列\n"

#: sys-utils/lsmem.c:510
#, fuzzy
msgid " -s, --sysroot <dir>  use the specified directory as system root\n"
msgstr " -s, --sysroot <目录>    以指定目录作为系统根目录\n"

#: sys-utils/lsmem.c:511
msgid "     --summary[=when] print summary information (never,always or only)\n"
msgstr ""

#: sys-utils/lsmem.c:618
#, fuzzy
msgid "unsupported --summary argument"
msgstr "不支持的 --setgroups 参数“%s”"

#: sys-utils/lsmem.c:633
#, fuzzy
msgid "options --{raw,json,pairs} and --summary=only are mutually exclusive"
msgstr "--setgroups=allow 和 --map-root-user 选项是互斥的"

#: sys-utils/lsmem.c:664 sys-utils/lsns.c:781
msgid "failed to initialize output table"
msgstr "初始化输出表失败"

#: sys-utils/lsmem.c:676
#, fuzzy
msgid "Failed to initialize output column"
msgstr "初始化输出列失败"

#: sys-utils/lsns.c:99
msgid "namespace identifier (inode number)"
msgstr "名字空间标识符 (inode 号)"

#: sys-utils/lsns.c:100
msgid "kind of namespace"
msgstr "名字空间类型"

#: sys-utils/lsns.c:101
msgid "path to the namespace"
msgstr "名字空间路径"

#: sys-utils/lsns.c:102
msgid "number of processes in the namespace"
msgstr "名字空间中的进程数"

#: sys-utils/lsns.c:103
msgid "lowest PID in the namespace"
msgstr "名字空间中的最低 PID"

#: sys-utils/lsns.c:104
msgid "PPID of the PID"
msgstr "PID 的 PPID"

#: sys-utils/lsns.c:105
msgid "command line of the PID"
msgstr "PID 的命令行"

#: sys-utils/lsns.c:106
msgid "UID of the PID"
msgstr "PID 的 UID"

#: sys-utils/lsns.c:107
msgid "username of the PID"
msgstr "PID 的用户名"

#: sys-utils/lsns.c:108
msgid "namespace ID as used by network subsystem"
msgstr ""

#: sys-utils/lsns.c:109
msgid "nsfs mountpoint (usually used network subsystem)"
msgstr ""

#: sys-utils/lsns.c:719
msgid "failed to add line to output"
msgstr "向输出添加行出错"

#: sys-utils/lsns.c:895
#, c-format
msgid " %s [options] [<namespace>]\n"
msgstr " %s [选项] [<名字空间>]\n"

#: sys-utils/lsns.c:898
msgid "List system namespaces.\n"
msgstr "列出系统名字空间。\n"

#: sys-utils/lsns.c:905
msgid " -p, --task <pid>       print process namespaces\n"
msgstr " -p, --task <pid>       打印进程名字空间\n"

#: sys-utils/lsns.c:908
#, fuzzy
msgid " -W, --nowrap           don't use multi-line representation\n"
msgstr " -n, --no-mtab           不写 /etc/mtab\n"

#: sys-utils/lsns.c:909
msgid " -t, --type <name>      namespace type (mnt, net, ipc, user, pid, uts, cgroup)\n"
msgstr " -t, --type <name>      名字空间类型(mnt, net, ipc, user, pid, uts, cgroup)\n"

#: sys-utils/lsns.c:1000
#, c-format
msgid "unknown namespace type: %s"
msgstr "未知的名字空间类型︰ %s"

#: sys-utils/lsns.c:1024
msgid "--task is mutually exclusive with <namespace>"
msgstr "--task 与 <名字空间> 互斥"

#: sys-utils/lsns.c:1025
msgid "invalid namespace argument"
msgstr "无效的名字空间参数"

#: sys-utils/lsns.c:1077
#, c-format
msgid "not found namespace: %ju"
msgstr "找不到名字空间︰ %ju"

#: sys-utils/mount.c:65 sys-utils/umount.c:120
#, c-format
msgid "only root can use \"--%s\" option (effective UID is %u)"
msgstr "只有 root 用户能使用“--%s”选项(有效 UID 是 %u)"

#: sys-utils/mount.c:68 sys-utils/umount.c:123
#, c-format
msgid "only root can do that (effective UID is %u)"
msgstr "只有 root 用户能执行该操作(有效 UID 为 %u)"

#: sys-utils/mount.c:72 sys-utils/umount.c:127
#, c-format
msgid "only root can use \"--%s\" option"
msgstr "只有 root 用户能使用“--%s”选项"

#: sys-utils/mount.c:73 sys-utils/umount.c:128
msgid "only root can do that"
msgstr "只有 root 能执行该操作"

#: sys-utils/mount.c:84 sys-utils/umount.c:62
#, c-format
msgid "%s from %s (libmount %s"
msgstr "%s，来自 %s(libmount %s"

#: sys-utils/mount.c:129
msgid "failed to read mtab"
msgstr "读取 mtab 失败"

#: sys-utils/mount.c:191 sys-utils/umount.c:184
#, c-format
msgid "%-25s: ignored\n"
msgstr "%-25s：已忽略\n"

#: sys-utils/mount.c:192
#, c-format
msgid "%-25s: already mounted\n"
msgstr "%-25s：已经挂载\n"

#: sys-utils/mount.c:248
#, c-format
msgid "%s: %s moved to %s.\n"
msgstr "%s：%s 已移到 %s。\n"

#: sys-utils/mount.c:250
#, c-format
msgid "%s: %s bound on %s.\n"
msgstr "%s：%s 已绑定到 %s 。\n"

#: sys-utils/mount.c:253 sys-utils/mount.c:257
#, c-format
msgid "%s: %s mounted on %s.\n"
msgstr "%s：%s 已挂臷到 %s。\n"

#: sys-utils/mount.c:255
#, c-format
msgid "%s: %s propagation flags changed.\n"
msgstr "%s：%s 传播标志已更改。\n"

#: sys-utils/mount.c:275
#, c-format
msgid ""
"mount: %s does not contain SELinux labels.\n"
"       You just mounted an file system that supports labels which does not\n"
"       contain labels, onto an SELinux box. It is likely that confined\n"
"       applications will generate AVC messages and not be allowed access to\n"
"       this file system.  For more details see restorecon(8) and mount(8).\n"
msgstr ""
"mount：%s 不包含 SELinux 标志\n"
"       您刚将一个支持标签但未包含标签的文件系统挂载到了 SELinux 机器上。\n"
"       受限制的应用程序可能会生成 AVC 消息，并被阻止访问该文件系统。\n"
"       更多详细信息请参阅 restorecon(8) 和 mount(8)。\n"

#: sys-utils/mount.c:307 sys-utils/umount.c:161
#, fuzzy, c-format
msgid "%s: %s."
msgstr "%15s: %s"

#: sys-utils/mount.c:333
#, c-format
msgid "%s: failed to parse"
msgstr "%s：解析失败"

#: sys-utils/mount.c:372
#, c-format
msgid "unsupported option format: %s"
msgstr "不支持的参数格式：%s"

#: sys-utils/mount.c:374
#, c-format
msgid "failed to append option '%s'"
msgstr "追加选项“%s”失败"

#: sys-utils/mount.c:392
#, c-format
msgid ""
" %1$s [-lhV]\n"
" %1$s -a [options]\n"
" %1$s [options] [--source] <source> | [--target] <directory>\n"
" %1$s [options] <source> <directory>\n"
" %1$s <operation> <mountpoint> [<target>]\n"
msgstr ""
" %1$s [-lhV]\n"
" %1$s -a [选项]\n"
" %1$s [选项] [--source] <源> | [--target] <目录>\n"
" %1$s [选项] <源> <目录>\n"
" %1$s <操作> <挂载点> [<目标>]\n"

#: sys-utils/mount.c:400
msgid "Mount a filesystem.\n"
msgstr "挂载文件系统。\n"

#: sys-utils/mount.c:404
#, c-format
msgid ""
" -a, --all               mount all filesystems mentioned in fstab\n"
" -c, --no-canonicalize   don't canonicalize paths\n"
" -f, --fake              dry run; skip the mount(2) syscall\n"
" -F, --fork              fork off for each device (use with -a)\n"
" -T, --fstab <path>      alternative file to /etc/fstab\n"
msgstr ""
" -a, --all               挂载 fstab 中的所有文件系统\n"
" -c, --no-canonicalize   不对路径规范化\n"
" -f, --fake              空运行；跳过 mount(2) 系统调用\n"
" -F, --fork              对每个设备禁用 fork(和 -a 选项一起使用)\n"
" -T, --fstab <路径>      /etc/fstab 的替代文件\n"

#: sys-utils/mount.c:410
#, c-format
msgid " -i, --internal-only     don't call the mount.<type> helpers\n"
msgstr " -i, --internal-only     不调用 mount.<type> 辅助程序\n"

#: sys-utils/mount.c:412
#, c-format
msgid " -l, --show-labels       show also filesystem labels\n"
msgstr " -l, --show-labels       也显示文件系统标签\n"

#: sys-utils/mount.c:414 sys-utils/umount.c:96
#, c-format
msgid " -n, --no-mtab           don't write to /etc/mtab\n"
msgstr " -n, --no-mtab           不写 /etc/mtab\n"

#: sys-utils/mount.c:416
#, c-format
msgid ""
" -o, --options <list>    comma-separated list of mount options\n"
" -O, --test-opts <list>  limit the set of filesystems (use with -a)\n"
" -r, --read-only         mount the filesystem read-only (same as -o ro)\n"
" -t, --types <list>      limit the set of filesystem types\n"
msgstr ""
" -o, --options <列表>    挂载选项列表，以英文逗号分隔\n"
" -O, --test-opts <列表>  限制文件系统集合(和 -a 选项一起使用)\n"
" -r, --read-only         以只读方式挂载文件系统(同 -o ro)\n"
" -t, --types <列表>      限制文件系统类型集合\n"

#: sys-utils/mount.c:421
#, c-format
msgid ""
"     --source <src>      explicitly specifies source (path, label, uuid)\n"
"     --target <target>   explicitly specifies mountpoint\n"
msgstr ""
"     --source <源>       指明源(路径、标签、uuid)\n"
"     --target <目标>     指明挂载点\n"

#: sys-utils/mount.c:424 sys-utils/umount.c:102
#, c-format
msgid " -v, --verbose           say what is being done\n"
msgstr " -v, --verbose           打印当前进行的操作\n"

#: sys-utils/mount.c:426
#, c-format
msgid " -w, --rw, --read-write  mount the filesystem read-write (default)\n"
msgstr " -w, --rw, --read-write  以读写方式挂载文件系统(默认)\n"

#: sys-utils/mount.c:432
#, c-format
msgid ""
"\n"
"Source:\n"
" -L, --label <label>     synonym for LABEL=<label>\n"
" -U, --uuid <uuid>       synonym for UUID=<uuid>\n"
" LABEL=<label>           specifies device by filesystem label\n"
" UUID=<uuid>             specifies device by filesystem UUID\n"
" PARTLABEL=<label>       specifies device by partition label\n"
" PARTUUID=<uuid>         specifies device by partition UUID\n"
msgstr ""
"\n"
"源：\n"
" -L, --label <标签>      同 LABEL=<label>\n"
" -U, --uuid <uuid>       同 UUID=<uuid>\n"
" LABEL=<标签>            按文件系统标签指定设备\n"
" UUID=<uuid>             按文件系统 UUID 指定设备\n"
" PARTLABEL=<标签>        按分区标签指定设备\n"
" PARTUUID=<uuid>         按分区 UUID 指定设备\n"

#: sys-utils/mount.c:441
#, c-format
msgid ""
" <device>                specifies device by path\n"
" <directory>             mountpoint for bind mounts (see --bind/rbind)\n"
" <file>                  regular file for loopdev setup\n"
msgstr ""
" <设备>                  按路径指定设备\n"
" <目录>                  绑定式挂载的挂载点(参阅 --bind/rbind)\n"
" <文件>                  用于设置回环设备的常规文件\n"

#: sys-utils/mount.c:446
#, c-format
msgid ""
"\n"
"Operations:\n"
" -B, --bind              mount a subtree somewhere else (same as -o bind)\n"
" -M, --move              move a subtree to some other place\n"
" -R, --rbind             mount a subtree and all submounts somewhere else\n"
msgstr ""
"\n"
"操作：\n"
" -B, --bind              挂载其他位置的子树(同 -o bind)\n"
" -M, --move              将子树移动到其他位置\n"
" -R, --rbind             挂载其他位置的子树及其包含的所有子挂载(submount)\n"

#: sys-utils/mount.c:451
#, c-format
msgid ""
" --make-shared           mark a subtree as shared\n"
" --make-slave            mark a subtree as slave\n"
" --make-private          mark a subtree as private\n"
" --make-unbindable       mark a subtree as unbindable\n"
msgstr ""
" --make-shared           将子树标记为 共享\n"
" --make-slave            将子树标记为 从属\n"
" --make-private          将子树标记为 私有\n"
" --make-unbindable       将子树标记为 不可绑定\n"

#: sys-utils/mount.c:456
#, c-format
msgid ""
" --make-rshared          recursively mark a whole subtree as shared\n"
" --make-rslave           recursively mark a whole subtree as slave\n"
" --make-rprivate         recursively mark a whole subtree as private\n"
" --make-runbindable      recursively mark a whole subtree as unbindable\n"
msgstr ""
" --make-rshared          递归地将整个子树标记为 共享\n"
" --make-rslave           递归地将整个子树标记为 从属\n"
" --make-rprivate         递归地将整个子树标记为 私有\n"
" --make-runbindable      递归地将整个子树标记为 不可绑定\n"

#: sys-utils/mount.c:544 sys-utils/umount.c:448
msgid "libmount context allocation failed"
msgstr "libmount 环境(context)分配失败"

#: sys-utils/mount.c:601 sys-utils/umount.c:501
msgid "failed to set options pattern"
msgstr "设置选项模式失败"

#: sys-utils/mount.c:757
msgid "source specified more than once"
msgstr "源指定了多次"

#: sys-utils/mountpoint.c:119
#, c-format
msgid ""
" %1$s [-qd] /path/to/directory\n"
" %1$s -x /dev/device\n"
msgstr ""
" %1$s [-qd] /目录/的/路径\n"
" %1$s -x /dev/设备\n"

#: sys-utils/mountpoint.c:123
msgid "Check whether a directory or file is a mountpoint.\n"
msgstr "检查目录或文件是否为挂载点。\n"

#: sys-utils/mountpoint.c:126
msgid ""
" -q, --quiet        quiet mode - don't print anything\n"
" -d, --fs-devno     print maj:min device number of the filesystem\n"
" -x, --devno        print maj:min device number of the block device\n"
msgstr ""
" -q, --quiet        安静模式 - 不打印任何信息\n"
" -d, --fs-devno     打印文件系统的 主：次 设备号\n"
" -x, --devno        打印块设备的主：次设备号\n"

#: sys-utils/mountpoint.c:196
#, c-format
msgid "%s is not a mountpoint\n"
msgstr "%s 不是一个挂载点\n"

#: sys-utils/mountpoint.c:202
#, c-format
msgid "%s is a mountpoint\n"
msgstr "%s 是一个挂载点\n"

#: sys-utils/nsenter.c:73 sys-utils/setarch.c:92 sys-utils/unshare.c:248
#, c-format
msgid " %s [options] [<program> [<argument>...]]\n"
msgstr " %s [选项] [<程序> [<参数>...]]\n"

#: sys-utils/nsenter.c:77
msgid "Run a program with namespaces of other processes.\n"
msgstr "以其他程序的名字空间运行某个程序。\n"

#: sys-utils/nsenter.c:80
#, fuzzy
msgid " -a, --all              enter all namespaces\n"
msgstr " -a, --all            打印所有设备\n"

#: sys-utils/nsenter.c:81
msgid " -t, --target <pid>     target process to get namespaces from\n"
msgstr " -t, --target <pid>     要获取名字空间的目标进程\n"

#: sys-utils/nsenter.c:82
msgid " -m, --mount[=<file>]   enter mount namespace\n"
msgstr " -m, --mount[=<文件>]   进入 mount 名字空间\n"

#: sys-utils/nsenter.c:83
msgid " -u, --uts[=<file>]     enter UTS namespace (hostname etc)\n"
msgstr " -u, --uts[=<文件>]     进入 UTS 名字空间(主机名等)\n"

#: sys-utils/nsenter.c:84
msgid " -i, --ipc[=<file>]     enter System V IPC namespace\n"
msgstr " -i, --ipc[=<文件>]     进入 System V IPC 名字空间\n"

#: sys-utils/nsenter.c:85
msgid " -n, --net[=<file>]     enter network namespace\n"
msgstr " -n, --net[=<文件>]     进入网络名字空间\n"

#: sys-utils/nsenter.c:86
msgid " -p, --pid[=<file>]     enter pid namespace\n"
msgstr " -p, --pid[=<文件>]     进入 pid 名字空间\n"

#: sys-utils/nsenter.c:87
msgid " -C, --cgroup[=<file>]  enter cgroup namespace\n"
msgstr " -C, --cgroup[=<文件>]  进入 cgroup 名字空间\n"

#: sys-utils/nsenter.c:88
msgid " -U, --user[=<file>]    enter user namespace\n"
msgstr " -U, --user[=<文件>]    进入用户名字空间\n"

#: sys-utils/nsenter.c:89
msgid " -S, --setuid <uid>     set uid in entered namespace\n"
msgstr " -S, --setuid <uid>     设置进入空间中的 uid\n"

#: sys-utils/nsenter.c:90
msgid " -G, --setgid <gid>     set gid in entered namespace\n"
msgstr " -G, --setgid <gid>     设置进入名字空间中的 gid\n"

#: sys-utils/nsenter.c:91
msgid "     --preserve-credentials do not touch uids or gids\n"
msgstr "     --preserve-credentials 不干涉 uid 或 gid\n"

#: sys-utils/nsenter.c:92
msgid " -r, --root[=<dir>]     set the root directory\n"
msgstr " -r, --root[=<目录>]     设置根目录\n"

#: sys-utils/nsenter.c:93
msgid " -w, --wd[=<dir>]       set the working directory\n"
msgstr " -w, --wd[=<dir>]       设置工作目录\n"

#: sys-utils/nsenter.c:94
msgid " -F, --no-fork          do not fork before exec'ing <program>\n"
msgstr " -F, --no-fork          执行 <程序> 前不 fork\n"

#: sys-utils/nsenter.c:96
msgid " -Z, --follow-context   set SELinux context according to --target PID\n"
msgstr " -Z, --follow-context  根据 --target PID 设置 SELinux 环境\n"

#: sys-utils/nsenter.c:121
#, c-format
msgid "neither filename nor target pid supplied for %s"
msgstr "没有为 %s 提供文件名或目标 pid"

#: sys-utils/nsenter.c:309
msgid "failed to parse uid"
msgstr "解析 uid 失败"

#: sys-utils/nsenter.c:313
msgid "failed to parse gid"
msgstr "解析 gid 失败"

#: sys-utils/nsenter.c:349
msgid "no target PID specified for --follow-context"
msgstr "没有为 --follow-context 设置目标 PID"

#: sys-utils/nsenter.c:351
#, c-format
msgid "failed to get %d SELinux context"
msgstr "未能获取 %d SELinux 环境"

#: sys-utils/nsenter.c:354
#, c-format
msgid "failed to set exec context to '%s'"
msgstr "向“%s”设置 exec 环境失败"

#: sys-utils/nsenter.c:361
#, fuzzy
msgid "no target PID specified for --all"
msgstr "没有为 --follow-context 设置目标 PID"

#: sys-utils/nsenter.c:425
#, c-format
msgid "reassociate to namespace '%s' failed"
msgstr "重新关联到名字空间“%s”失败"

#: sys-utils/nsenter.c:441
msgid "cannot open current working directory"
msgstr "打不开当前工作目录"

#: sys-utils/nsenter.c:448
msgid "change directory by root file descriptor failed"
msgstr "根据 root 文件描述符 更改目录失败"

#: sys-utils/nsenter.c:451
msgid "chroot failed"
msgstr "chroot 失败"

#: sys-utils/nsenter.c:461
msgid "change directory by working directory file descriptor failed"
msgstr "按工作目录文件描述符更改目录失败"

#: sys-utils/nsenter.c:472 sys-utils/setpriv.c:962 sys-utils/setpriv.c:969
msgid "setgroups failed"
msgstr "setgroups 失败"

#: sys-utils/pivot_root.c:34
#, c-format
msgid " %s [options] new_root put_old\n"
msgstr " %s [选项] 新根目录 旧根目录更名\n"

#: sys-utils/pivot_root.c:38
msgid "Change the root filesystem.\n"
msgstr "更改根文件系统。\n"

#: sys-utils/pivot_root.c:76
#, c-format
msgid "failed to change root from `%s' to `%s'"
msgstr "将根目录从“%s”更改为“%s”失败"

#: sys-utils/prlimit.c:75
msgid "address space limit"
msgstr "地址空间限制"

#: sys-utils/prlimit.c:76
msgid "max core file size"
msgstr "最大核心文件尺寸"

#: sys-utils/prlimit.c:77
msgid "CPU time"
msgstr "CPU 时间"

#: sys-utils/prlimit.c:77
msgid "seconds"
msgstr "秒数"

#: sys-utils/prlimit.c:78
msgid "max data size"
msgstr "最大数据尺寸"

#: sys-utils/prlimit.c:79
msgid "max file size"
msgstr "最大文件尺寸"

#: sys-utils/prlimit.c:80
msgid "max number of file locks held"
msgstr "最大文件锁保持数量"

#: sys-utils/prlimit.c:80
msgid "locks"
msgstr "锁"

#: sys-utils/prlimit.c:81
msgid "max locked-in-memory address space"
msgstr "最大内存锁定(locked-in-memory)地址空间"

#: sys-utils/prlimit.c:82
msgid "max bytes in POSIX mqueues"
msgstr "POSIX 消息队列中的最大字节数"

#: sys-utils/prlimit.c:83
msgid "max nice prio allowed to raise"
msgstr "允许提升的最大 nice 优先级"

#: sys-utils/prlimit.c:84
msgid "max number of open files"
msgstr "打开文件的最大数量"

#: sys-utils/prlimit.c:84
msgid "files"
msgstr "文件"

#: sys-utils/prlimit.c:85
msgid "max number of processes"
msgstr "最大进程数"

#: sys-utils/prlimit.c:85
msgid "processes"
msgstr "进程"

#: sys-utils/prlimit.c:86
msgid "max resident set size"
msgstr "最大驻留集尺寸"

#: sys-utils/prlimit.c:87
msgid "max real-time priority"
msgstr "最大实时优先级"

#: sys-utils/prlimit.c:88
msgid "timeout for real-time tasks"
msgstr "实时任务超时"

#: sys-utils/prlimit.c:88
msgid "microsecs"
msgstr "毫秒数"

#: sys-utils/prlimit.c:89
msgid "max number of pending signals"
msgstr "挂起(pending)信号的最大数量"

#: sys-utils/prlimit.c:89
msgid "signals"
msgstr "信号"

#: sys-utils/prlimit.c:90
msgid "max stack size"
msgstr "最大栈(stack)尺寸"

#: sys-utils/prlimit.c:123
msgid "resource name"
msgstr "资源名称"

#: sys-utils/prlimit.c:124
msgid "resource description"
msgstr "资源描述"

#: sys-utils/prlimit.c:125
msgid "soft limit"
msgstr "软限制"

#: sys-utils/prlimit.c:126
msgid "hard limit (ceiling)"
msgstr "硬限制(触顶)"

#: sys-utils/prlimit.c:127
msgid "units"
msgstr "单位"

#: sys-utils/prlimit.c:162
#, c-format
msgid " %s [options] [-p PID]\n"
msgstr " %s [选项] [-p PID]\n"

#: sys-utils/prlimit.c:164
#, c-format
msgid " %s [options] COMMAND\n"
msgstr " %s [选项] 命令\n"

#: sys-utils/prlimit.c:167
msgid "Show or change the resource limits of a process.\n"
msgstr "显示或更改进程的资源限制。 \n"

#: sys-utils/prlimit.c:169
msgid ""
"\n"
"General Options:\n"
msgstr ""
"\n"
"常规选项：\n"

#: sys-utils/prlimit.c:170
#, fuzzy
msgid ""
" -p, --pid <pid>        process id\n"
" -o, --output <list>    define which output columns to use\n"
"     --noheadings       don't print headings\n"
"     --raw              use the raw output format\n"
"     --verbose          verbose output\n"
msgstr ""
" -p, --pid <pid>        进程 id\n"
" -o, --output <列表>    定义要使用的输出列\n"
"     --noheadings       不打印标题\n"
"     --raw              使用原生输出格式\n"
"     --verbose          详尽输出\n"
" -h, --help             显示此帮助并退出\n"
" -V, --version          输出版本信息并退出\n"

#: sys-utils/prlimit.c:178
msgid ""
"\n"
"Resources Options:\n"
msgstr ""
"\n"
"资源选项：\n"

#: sys-utils/prlimit.c:179
msgid ""
" -c, --core             maximum size of core files created\n"
" -d, --data             maximum size of a process's data segment\n"
" -e, --nice             maximum nice priority allowed to raise\n"
" -f, --fsize            maximum size of files written by the process\n"
" -i, --sigpending       maximum number of pending signals\n"
" -l, --memlock          maximum size a process may lock into memory\n"
" -m, --rss              maximum resident set size\n"
" -n, --nofile           maximum number of open files\n"
" -q, --msgqueue         maximum bytes in POSIX message queues\n"
" -r, --rtprio           maximum real-time scheduling priority\n"
" -s, --stack            maximum stack size\n"
" -t, --cpu              maximum amount of CPU time in seconds\n"
" -u, --nproc            maximum number of user processes\n"
" -v, --as               size of virtual memory\n"
" -x, --locks            maximum number of file locks\n"
" -y, --rttime           CPU time in microseconds a process scheduled\n"
"                        under real-time scheduling\n"
msgstr ""
" -c, --core             创建核心文件的最大尺寸\n"
" -d, --data             进程数据段的最大尺寸\n"
" -e, --nice             允许提升的最大 nice 优先级\n"
" -f, --fsize            进程写文件的最大尺寸\n"
" -i, --sigpending       挂起(pending)信号的最大数量\n"
" -l, --memlock          内存中进程锁的最大数量\n"
" -m, --rss              (内存虚拟页)驻留集的最大数量\n"
" -n, --nofile           打开文件的最大数量\n"
" -q, --msgqueue         POSIX 消息队列的最大字节数\n"
" -r, --rtprio           最大实时调度优先级\n"
" -s, --stack            最大栈(stack)尺寸\n"
" -t, --cpu              最长 CPU 时间(秒)\n"
" -u, --nproc            最多用户进程数量\n"
" -v, --as               虚拟内存大小\n"
" -x, --locks            文件锁的最大数量\n"
" -y, --rttime           实时调度时进程调度的 CPU\n"
"                        (间隔)时间(毫秒)\n"

#: sys-utils/prlimit.c:243 sys-utils/prlimit.c:249 sys-utils/prlimit.c:365
#: sys-utils/prlimit.c:370
msgid "unlimited"
msgstr "无限制"

#: sys-utils/prlimit.c:331
#, c-format
msgid "failed to get old %s limit"
msgstr "获取旧的 %s 限制失败"

#: sys-utils/prlimit.c:355
#, c-format
msgid "the soft limit %s cannot exceed the hard limit"
msgstr "软限制 %s 不能超过硬限制"

#: sys-utils/prlimit.c:362
#, c-format
msgid "New %s limit for pid %d: "
msgstr "pid %2$d 的新 %1$s 限制："

#: sys-utils/prlimit.c:377
#, c-format
msgid "failed to set the %s resource limit"
msgstr "设置 %s 资源限制失败"

#: sys-utils/prlimit.c:378
#, c-format
msgid "failed to get the %s resource limit"
msgstr "获取 %s 资源限制失败"

#: sys-utils/prlimit.c:455
#, c-format
msgid "failed to parse %s limit"
msgstr "解析 %s 限制失败"

#: sys-utils/prlimit.c:584
msgid "option --pid may be specified only once"
msgstr "--pid 选项只能指定一次"

#: sys-utils/prlimit.c:614
msgid "options --pid and COMMAND are mutually exclusive"
msgstr "--pid 和 命令 互相排斥"

#: sys-utils/readprofile.c:107
msgid "Display kernel profiling information.\n"
msgstr "显示内核分析信息。\n"

#: sys-utils/readprofile.c:111
#, c-format
msgid " -m, --mapfile <mapfile>   (defaults: \"%s\" and\n"
msgstr " -m, --mapfile <映射文件>  (默认：“%s”和\n"

#: sys-utils/readprofile.c:113
#, c-format
msgid "                                      \"%s\")\n"
msgstr "                                      “%s”)\n"

#: sys-utils/readprofile.c:115
#, c-format
msgid " -p, --profile <pro-file>  (default:  \"%s\")\n"
msgstr " -p, --profile <pro-file>  (默认：“%s”)\n"

#: sys-utils/readprofile.c:116
msgid " -M, --multiplier <mult>   set the profiling multiplier to <mult>\n"
msgstr " -M, --multiplier <乘数>   将性能测试乘数设置为<乘数>\n"

#: sys-utils/readprofile.c:117
msgid " -i, --info                print only info about the sampling step\n"
msgstr " -i, --info                只打印有关采样步骤(sampling step)的信息\n"

#: sys-utils/readprofile.c:118
msgid " -v, --verbose             print verbose data\n"
msgstr " -v, --verbose             打印详细信息\n"

#: sys-utils/readprofile.c:119
msgid " -a, --all                 print all symbols, even if count is 0\n"
msgstr " -a, --all                 打印所有符号，即使计数为 0\n"

#: sys-utils/readprofile.c:120
msgid " -b, --histbin             print individual histogram-bin counts\n"
msgstr " -b, --histbin             打印各个直方图区间的计数\n"

#: sys-utils/readprofile.c:121
msgid " -s, --counters            print individual counters within functions\n"
msgstr " -s, --counters            打印函数内的独立计数\n"

#: sys-utils/readprofile.c:122
msgid " -r, --reset               reset all the counters (root only)\n"
msgstr " -r, --reset               重置所有计数(限 root 用户)\n"

#: sys-utils/readprofile.c:123
msgid " -n, --no-auto             disable byte order auto-detection\n"
msgstr " -n, --no-auto             禁用字节顺序自动检测\n"

#: sys-utils/readprofile.c:239
#, c-format
msgid "error writing %s"
msgstr "写 %s 出错"

#: sys-utils/readprofile.c:270
msgid "Assuming reversed byte order. Use -n to force native byte order."
msgstr "将假设为反向字节顺序。可使用 -n 强制为原生字节顺序。"

#: sys-utils/readprofile.c:285
#, c-format
msgid "Sampling_step: %u\n"
msgstr "采样步长：%u\n"

#: sys-utils/readprofile.c:301 sys-utils/readprofile.c:322
#, c-format
msgid "%s(%i): wrong map line"
msgstr "%s(%i)：错误的 map 行"

#: sys-utils/readprofile.c:312
#, c-format
msgid "can't find \"_stext\" in %s"
msgstr "在 %s 中找不到“_stext”"

#: sys-utils/readprofile.c:345
msgid "profile address out of range. Wrong map file?"
msgstr "配置(profile)地址超出范围。map 文件错误？"

#: sys-utils/readprofile.c:403
msgid "total"
msgstr "总计"

#: sys-utils/renice.c:52
msgid "process ID"
msgstr "进程 ID"

#: sys-utils/renice.c:53
msgid "process group ID"
msgstr "进程组 ID"

#: sys-utils/renice.c:62
#, c-format
msgid ""
" %1$s [-n] <priority> [-p|--pid] <pid>...\n"
" %1$s [-n] <priority>  -g|--pgrp <pgid>...\n"
" %1$s [-n] <priority>  -u|--user <user>...\n"
msgstr ""
" %1$s [-n] <优先级> [-p|--pid] <pid>...\n"
" %1$s [-n] <优先级>  -g|--pgrp <pgid>...\n"
" %1$s [-n] <优先级>  -u|--user <用户>...\n"

#: sys-utils/renice.c:68
msgid "Alter the priority of running processes.\n"
msgstr "改变运行进程的优先级。 \n"

#: sys-utils/renice.c:71
msgid " -n, --priority <num>   specify the nice increment value\n"
msgstr " -n, --priority <数字>  指定 nice 增量\n"

#: sys-utils/renice.c:72
msgid " -p, --pid <id>         interpret argument as process ID (default)\n"
msgstr " -p, --pid <id>         将参数解释为进程 ID (默认)\n"

#: sys-utils/renice.c:73
msgid " -g, --pgrp <id>        interpret argument as process group ID\n"
msgstr " -g, --pgrp <id>        将参数解释为进程组 ID\n"

#: sys-utils/renice.c:74
msgid " -u, --user <name>|<id> interpret argument as username or user ID\n"
msgstr " -u, --user <name>|<id> 将参数解释为 用户名 或 用户 ID\n"

#: sys-utils/renice.c:86
#, c-format
msgid "failed to get priority for %d (%s)"
msgstr "获取 %d (%s) 的优先级失败"

#: sys-utils/renice.c:99
#, c-format
msgid "failed to set priority for %d (%s)"
msgstr "设置 %d 的优先级失败(%s)"

#: sys-utils/renice.c:104
#, c-format
msgid "%d (%s) old priority %d, new priority %d\n"
msgstr "%d (%s) 旧优先级为 %d，新优先级为 %d\n"

#: sys-utils/renice.c:152
#, fuzzy, c-format
msgid "invalid priority '%s'"
msgstr "无效 ID：%s"

#: sys-utils/renice.c:179
#, c-format
msgid "unknown user %s"
msgstr "未知用户 %s"

#. TRANSLATORS: The first %s is one of the above
#. * three ID names. Read: "bad value for %s: %s"
#: sys-utils/renice.c:188
#, c-format
msgid "bad %s value: %s"
msgstr "错误的 %s 值：%s"

#: sys-utils/rfkill.c:129
#, fuzzy
msgid "kernel device name"
msgstr "内部内核设备名称"

#: sys-utils/rfkill.c:130
#, fuzzy
msgid "device identifier value"
msgstr "设备标识符"

#: sys-utils/rfkill.c:131
msgid "device type name that can be used as identifier"
msgstr ""

#: sys-utils/rfkill.c:132
#, fuzzy
msgid "device type description"
msgstr "标志描述"

#: sys-utils/rfkill.c:133
#, fuzzy
msgid "status of software block"
msgstr "锁的大小"

#: sys-utils/rfkill.c:134
#, fuzzy
msgid "status of hardware block"
msgstr "显示硬件看门狗的状态。\n"

#: sys-utils/rfkill.c:198
#, fuzzy, c-format
msgid "cannot set non-blocking %s"
msgstr "无法锁定 %s"

#: sys-utils/rfkill.c:219
#, c-format
msgid "wrong size of rfkill event: %zu < %d"
msgstr ""

#: sys-utils/rfkill.c:249
#, fuzzy, c-format
msgid "failed to poll %s"
msgstr "解析 %s 失败"

#: sys-utils/rfkill.c:313
#, fuzzy
msgid "invalid identifier"
msgstr "设备标识符"

#: sys-utils/rfkill.c:393 sys-utils/rfkill.c:396
#, fuzzy
msgid "blocked"
msgstr "已锁定"

#: sys-utils/rfkill.c:393 sys-utils/rfkill.c:396
#, fuzzy
msgid "unblocked"
msgstr "已锁定"

#: sys-utils/rfkill.c:415 sys-utils/rfkill.c:480 sys-utils/rfkill.c:524
#, fuzzy, c-format
msgid "invalid identifier: %s"
msgstr "磁盘标识符：%s"

#: sys-utils/rfkill.c:566
#, fuzzy, c-format
msgid " %s [options] command [identifier ...]\n"
msgstr " %s [选项] [<设备> ...]\n"

#: sys-utils/rfkill.c:569
msgid "Tool for enabling and disabling wireless devices.\n"
msgstr ""

#. TRANSLATORS: command names should not be translated, explaining
#. them as additional field after identifier is fine, for example
#. *
#. list   [identifier]   (lista [tarkenne])
#.
#: sys-utils/rfkill.c:592
#, fuzzy
msgid " help\n"
msgstr " -help\n"

#: sys-utils/rfkill.c:593
msgid " event\n"
msgstr ""

#: sys-utils/rfkill.c:594
#, fuzzy
msgid " list   [identifier]\n"
msgstr "磁盘标识符"

#: sys-utils/rfkill.c:595
#, fuzzy
msgid " block   identifier\n"
msgstr "磁盘标识符"

#: sys-utils/rfkill.c:596
#, fuzzy
msgid " unblock identifier\n"
msgstr "磁盘标识符"

#: sys-utils/rtcwake.c:101
msgid "Enter a system sleep state until a specified wakeup time.\n"
msgstr "进入系统睡眠状态，直到指定的唤醒时间。\n"

#: sys-utils/rtcwake.c:104
msgid " -a, --auto               reads the clock mode from adjust file (default)\n"
msgstr " -a, --auto               从 adjust 文件读取时钟模式(默认)\n"

#: sys-utils/rtcwake.c:106
#, c-format
msgid ""
" -A, --adjfile <file>     specifies the path to the adjust file\n"
"                            the default is %s\n"
msgstr ""
" -A, --adjfile <文件>     指定 adjust 文件的路径\n"
"                            默认为 %s\n"

#: sys-utils/rtcwake.c:108
msgid "     --date <timestamp>   date time of timestamp to wake\n"
msgstr "     --date <时间戳>      唤醒时间戳的日期时间\n"

#: sys-utils/rtcwake.c:109
msgid " -d, --device <device>    select rtc device (rtc0|rtc1|...)\n"
msgstr " -d, --device <设备>      选择 rtc 设备(rtc0|rtc1|...)\n"

#: sys-utils/rtcwake.c:110
msgid " -n, --dry-run            does everything, but suspend\n"
msgstr " -n, --dry-run            演示操作但不执行(suspend)\n"

#: sys-utils/rtcwake.c:111
msgid " -l, --local              RTC uses local timezone\n"
msgstr " -l, --local              RTC 使用本地时区\n"

#: sys-utils/rtcwake.c:112
msgid "     --list-modes         list available modes\n"
msgstr "     --list-modes         列出可用模式\n"

#: sys-utils/rtcwake.c:113
msgid " -m, --mode <mode>        standby|mem|... sleep mode\n"
msgstr " -m, --mode <模式>        指定 standby|mem|... 等睡眠模式\n"

#: sys-utils/rtcwake.c:114
msgid " -s, --seconds <seconds>  seconds to sleep\n"
msgstr " -s, --seconds <秒数>     指定睡眠的秒数\n"

#: sys-utils/rtcwake.c:115
msgid " -t, --time <time_t>      time to wake\n"
msgstr " -t, --time <time_t>      指定唤醒时刻\n"

#: sys-utils/rtcwake.c:116
msgid " -u, --utc                RTC uses UTC\n"
msgstr " -u, --utc                RTC 使用 UTC\n"

#: sys-utils/rtcwake.c:117
msgid " -v, --verbose            verbose messages\n"
msgstr " -v, --verbose            输出详尽消息\n"

#: sys-utils/rtcwake.c:167
msgid "read rtc time failed"
msgstr "读取 rtc 时间失败"

#: sys-utils/rtcwake.c:173
msgid "read system time failed"
msgstr "读取系统时间失败"

#: sys-utils/rtcwake.c:189
msgid "convert rtc time failed"
msgstr "转换 rtc 时间失败"

#: sys-utils/rtcwake.c:237
msgid "set rtc wake alarm failed"
msgstr "设置 rtc 唤醒闹钟失败"

#: sys-utils/rtcwake.c:274
#, fuzzy
msgid "discarding stdin"
msgstr "忽略对齐偏移量"

#: sys-utils/rtcwake.c:325
#, c-format
msgid "unexpected third line in: %s: %s"
msgstr "第 3 行异常：%s：%s"

#: sys-utils/rtcwake.c:338 sys-utils/rtcwake.c:642
msgid "read rtc alarm failed"
msgstr "读取 rtc 闹钟失败"

#: sys-utils/rtcwake.c:343
#, c-format
msgid "alarm: off\n"
msgstr "闹钟：关\n"

#: sys-utils/rtcwake.c:356
msgid "convert time failed"
msgstr "转换时间失败"

#: sys-utils/rtcwake.c:361
#, c-format
msgid "alarm: on  %s"
msgstr "闹钟：于  %s"

#: sys-utils/rtcwake.c:405
#, c-format
msgid "could not read: %s"
msgstr "无法读取︰%s"

#: sys-utils/rtcwake.c:485
#, c-format
msgid "unrecognized suspend state '%s'"
msgstr "不支持的挂起状态“%s”"

#: sys-utils/rtcwake.c:493
msgid "invalid seconds argument"
msgstr "无效的 秒数 参数"

#: sys-utils/rtcwake.c:497
msgid "invalid time argument"
msgstr "无效的 时间 参数"

#: sys-utils/rtcwake.c:524
#, c-format
msgid "%s: assuming RTC uses UTC ...\n"
msgstr "%s：将假设 RTC 使用 UTC...\n"

#: sys-utils/rtcwake.c:529
msgid "Using UTC time.\n"
msgstr "使用 UTC 时间。\n"

#: sys-utils/rtcwake.c:530
msgid "Using local time.\n"
msgstr "使用当地时间。\n"

#: sys-utils/rtcwake.c:533
msgid "must provide wake time (see --seconds, --time and --date options)"
msgstr "必须提供唤醒时间(见 --seconds, --time 和 --date 选项)"

#: sys-utils/rtcwake.c:539
#, c-format
msgid "%s not enabled for wakeup events"
msgstr "%s 没有为唤醒事件启用"

#: sys-utils/rtcwake.c:546
#, c-format
msgid "alarm %ld, sys_time %ld, rtc_time %ld, seconds %u\n"
msgstr "闹钟 %ld，sys 时间 %ld，rtc 时间 %ld，秒数 %u\n"

#: sys-utils/rtcwake.c:553
#, c-format
msgid "time doesn't go backward to %s"
msgstr "时间不能返回到 %s"

#: sys-utils/rtcwake.c:563
#, c-format
msgid "%s: wakeup using %s at %s"
msgstr "%1$s：用 %3$s 的 %2$s 唤醒"

#: sys-utils/rtcwake.c:567
#, c-format
msgid "%s: wakeup from \"%s\" using %s at %s"
msgstr "%s：从“%s”唤醒，使用 %s，时间 %s"

#: sys-utils/rtcwake.c:577
#, c-format
msgid "suspend mode: no; leaving\n"
msgstr "挂起模式：无；将离开\n"

#: sys-utils/rtcwake.c:586
#, c-format
msgid "suspend mode: off; executing %s\n"
msgstr "挂起模式：关；正在执行 %s\n"

#: sys-utils/rtcwake.c:605
#, c-format
msgid "suspend mode: on; reading rtc\n"
msgstr "挂起模式：开；正在读 rtc\n"

#: sys-utils/rtcwake.c:610
msgid "rtc read failed"
msgstr "读 rtc 失败"

#: sys-utils/rtcwake.c:622
#, c-format
msgid "suspend mode: disable; disabling alarm\n"
msgstr "挂起模式：禁用；正在禁用闹钟\n"

#: sys-utils/rtcwake.c:626
#, c-format
msgid "suspend mode: show; printing alarm info\n"
msgstr "挂起模式：显示；正在打印闹钟信息\n"

#: sys-utils/rtcwake.c:633
#, c-format
msgid "suspend mode: %s; suspending system\n"
msgstr "挂起模式：%s；正在挂起系统\n"

#: sys-utils/rtcwake.c:647
msgid "disable rtc alarm interrupt failed"
msgstr "禁用 rtc 闹钟中断失败"

#: sys-utils/setarch.c:48
#, c-format
msgid "Switching on %s.\n"
msgstr "正在打开 %s。\n"

#: sys-utils/setarch.c:90
#, c-format
msgid " %s <arch> [options] [<program> [<argument>...]]\n"
msgstr " %s <架构> [选项] [<程序> [<参数>...]]\n"

#: sys-utils/setarch.c:95
msgid "Change the reported architecture and set personality flags.\n"
msgstr "更改报告的架构并设置人格标志(personality flag) 。\n"

#: sys-utils/setarch.c:98
msgid " -B, --32bit              turns on ADDR_LIMIT_32BIT\n"
msgstr " -B, --32bit              开启 ADDR_LIMIT_32BIT\n"

#: sys-utils/setarch.c:99
msgid " -F, --fdpic-funcptrs     makes function pointers point to descriptors\n"
msgstr " -F, --fdpic-funcptrs     将程序指针指向描述符\n"

#: sys-utils/setarch.c:100
msgid " -I, --short-inode        turns on SHORT_INODE\n"
msgstr " -I, --short-inode        开启 SHORT_INODE\n"

#: sys-utils/setarch.c:101
msgid " -L, --addr-compat-layout changes the way virtual memory is allocated\n"
msgstr " -L, --addr-compat-layout 更改虚拟内存分配的方式\n"

#: sys-utils/setarch.c:102
msgid " -R, --addr-no-randomize  disables randomization of the virtual address space\n"
msgstr " -R, --addr-no-randomize  禁止随机化虚拟地址空间\n"

#: sys-utils/setarch.c:103
msgid " -S, --whole-seconds      turns on WHOLE_SECONDS\n"
msgstr " -S, --whole-seconds      开启 WHOLE_SECONDS\n"

#: sys-utils/setarch.c:104
msgid " -T, --sticky-timeouts    turns on STICKY_TIMEOUTS\n"
msgstr " -T, --sticky-timeouts    开启 STICKY_TIMEOUTS\n"

#: sys-utils/setarch.c:105
msgid " -X, --read-implies-exec  turns on READ_IMPLIES_EXEC\n"
msgstr " -X, --read-implies-exec  开启 READ_IMPLIES_EXEC\n"

#: sys-utils/setarch.c:106
msgid " -Z, --mmap-page-zero     turns on MMAP_PAGE_ZERO\n"
msgstr " -Z, --mmap-page-zero     开启 MMAP_PAGE_ZERO\n"

#: sys-utils/setarch.c:107
msgid " -3, --3gb                limits the used address space to a maximum of 3 GB\n"
msgstr " -3, --3gb                将用户地址空间限制为最多 3 GB\n"

#: sys-utils/setarch.c:108
msgid "     --4gb                ignored (for backward compatibility only)\n"
msgstr "     --4gb                忽略(纯为兼容)\n"

#: sys-utils/setarch.c:109
msgid "     --uname-2.6          turns on UNAME26\n"
msgstr "     --uname-2.6          开启 UNAME26\n"

#: sys-utils/setarch.c:110
msgid " -v, --verbose            say what options are being switched on\n"
msgstr " -v, --verbose            告知打开了哪些选项\n"

#: sys-utils/setarch.c:113
msgid "     --list               list settable architectures, and exit\n"
msgstr "     --list               列出可设置的架构并退出\n"

#: sys-utils/setarch.c:217
#, c-format
msgid "%s: Unrecognized architecture"
msgstr "%s：未识别的架构"

#: sys-utils/setarch.c:238
#, c-format
msgid "Kernel cannot set architecture to %s"
msgstr "内核不能设置为 %s 的架构"

#: sys-utils/setarch.c:286
msgid "Not enough arguments"
msgstr "参数不够"

#: sys-utils/setarch.c:295
#, c-format
msgid "Failed to set personality to %s"
msgstr "无法将人格(personality)设置为 %s"

#: sys-utils/setarch.c:360
msgid "unrecognized option '--list'"
msgstr "无法识别的“--list”选项"

#: sys-utils/setarch.c:368
msgid "no architecture argument specified"
msgstr "未指定架构参数"

#: sys-utils/setarch.c:374
#, c-format
msgid "failed to set personality to %s"
msgstr "无法将人格(personality)设置为 %s"

#: sys-utils/setarch.c:377
#, c-format
msgid "Execute command `%s'.\n"
msgstr "执行命令“%s”。\n"

#: sys-utils/setpriv.c:115
#, c-format
msgid " %s [options] <program> [<argument>...]\n"
msgstr " %s [选项] <程序> [<参数>...]\n"

#: sys-utils/setpriv.c:119
msgid "Run a program with different privilege settings.\n"
msgstr "以不同的权限设置运行程序。\n"

#: sys-utils/setpriv.c:122
#, fuzzy
msgid " -d, --dump                  show current state (and do not exec)\n"
msgstr " -d, --dump               显示当前状态(不执行任何操作)\n"

#: sys-utils/setpriv.c:123
#, fuzzy
msgid " --nnp, --no-new-privs       disallow granting new privileges\n"
msgstr " --nnp, --no-new-privs    禁止赋予新权限\n"

#: sys-utils/setpriv.c:124
#, fuzzy
msgid " --ambient-caps <caps,...>   set ambient capabilities\n"
msgstr " --inh-caps <caps,...>    设置可继承的权能\n"

#: sys-utils/setpriv.c:125
#, fuzzy
msgid " --inh-caps <caps,...>       set inheritable capabilities\n"
msgstr " --inh-caps <caps,...>    设置可继承的权能\n"

#: sys-utils/setpriv.c:126
#, fuzzy
msgid " --bounding-set <caps>       set capability bounding set\n"
msgstr " --bounding-set <caps>    设置权能绑定集\n"

#: sys-utils/setpriv.c:127
#, fuzzy
msgid " --ruid <uid>                set real uid\n"
msgstr " --ruid <uid>             设置实际 uid\n"

#: sys-utils/setpriv.c:128
#, fuzzy
msgid " --euid <uid>                set effective uid\n"
msgstr " --euid <uid>             设置有效 uid\n"

#: sys-utils/setpriv.c:129
#, fuzzy
msgid " --rgid <gid>                set real gid\n"
msgstr " --rgid <gid>             设置实际 gid\n"

#: sys-utils/setpriv.c:130
#, fuzzy
msgid " --egid <gid>                set effective gid\n"
msgstr " --egid <gid>             设置有效 gid\n"

#: sys-utils/setpriv.c:131
#, fuzzy
msgid " --reuid <uid>               set real and effective uid\n"
msgstr " --reuid <uid>            设置实际和有效 uid\n"

#: sys-utils/setpriv.c:132
#, fuzzy
msgid " --regid <gid>               set real and effective gid\n"
msgstr " --regid <gid>            设置实际和有效 gid\n"

#: sys-utils/setpriv.c:133
#, fuzzy
msgid " --clear-groups              clear supplementary groups\n"
msgstr " --clear-groups           清除附属组\n"

#: sys-utils/setpriv.c:134
#, fuzzy
msgid " --keep-groups               keep supplementary groups\n"
msgstr " --keep-groups            保留附属组\n"

#: sys-utils/setpriv.c:135
#, fuzzy
msgid " --init-groups               initialize supplementary groups\n"
msgstr " --keep-groups            保留附属组\n"

#: sys-utils/setpriv.c:136
#, fuzzy
msgid " --groups <group,...>        set supplementary groups\n"
msgstr " --groups <组,...>        设置附属组\n"

#: sys-utils/setpriv.c:137
#, fuzzy
msgid " --securebits <bits>         set securebits\n"
msgstr " --securebits <位>        设置安全位\n"

#: sys-utils/setpriv.c:138
#, fuzzy
msgid " --selinux-label <label>     set SELinux label\n"
msgstr " --selinux-label <标签>  设置 SELinux 标签\n"

#: sys-utils/setpriv.c:139
#, fuzzy
msgid " --apparmor-profile <pr>     set AppArmor profile\n"
msgstr " --apparmor-profile <pr>  设置 AppArmor 配置文件\n"

#: sys-utils/setpriv.c:144
msgid " This tool can be dangerous.  Read the manpage, and be careful.\n"
msgstr "运行此工具有风险。请阅读 man 手册，谨慎操作。\n"

#: sys-utils/setpriv.c:187
#, fuzzy
msgid "invalid capability type"
msgstr "错误的权能字符串"

#: sys-utils/setpriv.c:239 sys-utils/setpriv.c:552
msgid "getting process secure bits failed"
msgstr "获取进程安全位失败"

#: sys-utils/setpriv.c:243
#, c-format
msgid "Securebits: "
msgstr "安全位："

#: sys-utils/setpriv.c:263
#, c-format
msgid "[none]\n"
msgstr "[无]\n"

#: sys-utils/setpriv.c:289
#, c-format
msgid "%s: too long"
msgstr "%s：过长"

#: sys-utils/setpriv.c:317
#, c-format
msgid "Supplementary groups: "
msgstr "附属组："

#: sys-utils/setpriv.c:319 sys-utils/setpriv.c:367 sys-utils/setpriv.c:372
#: sys-utils/setpriv.c:378 sys-utils/setpriv.c:384 sys-utils/setpriv.c:391
#, c-format
msgid "[none]"
msgstr "[无]"

#: sys-utils/setpriv.c:339
#, c-format
msgid "uid: %u\n"
msgstr "uid：%u\n"

#: sys-utils/setpriv.c:340
#, c-format
msgid "euid: %u\n"
msgstr "euid：%u\n"

#: sys-utils/setpriv.c:343
#, c-format
msgid "suid: %u\n"
msgstr "suid：%u\n"

#: sys-utils/setpriv.c:345 sys-utils/setpriv.c:445
msgid "getresuid failed"
msgstr "getresuid 失败"

#: sys-utils/setpriv.c:354 sys-utils/setpriv.c:460
msgid "getresgid failed"
msgstr "getresgid 失败"

#: sys-utils/setpriv.c:365
#, c-format
msgid "Effective capabilities: "
msgstr "有效权能："

#: sys-utils/setpriv.c:370
#, c-format
msgid "Permitted capabilities: "
msgstr "允许的权能："

#: sys-utils/setpriv.c:376
#, c-format
msgid "Inheritable capabilities: "
msgstr "可继承的权能："

#: sys-utils/setpriv.c:381
#, fuzzy, c-format
msgid "Ambient capabilities: "
msgstr "允许的权能："

#: sys-utils/setpriv.c:386
#, fuzzy, c-format
msgid "[unsupported]"
msgstr "不支持的命令"

#: sys-utils/setpriv.c:389
#, c-format
msgid "Capability bounding set: "
msgstr "权能绑定集："

#: sys-utils/setpriv.c:397
msgid "SELinux label"
msgstr "SELinux 标签"

#: sys-utils/setpriv.c:400
msgid "AppArmor profile"
msgstr "AppArmor 配置文件"

#: sys-utils/setpriv.c:413
#, c-format
msgid "cap %d: libcap-ng is broken"
msgstr "权能 %d：libcap-ng 损坏"

#: sys-utils/setpriv.c:436
msgid "Invalid supplementary group id"
msgstr "无效的附属组 id"

#: sys-utils/setpriv.c:453
msgid "setresuid failed"
msgstr "setresuid 失败"

#: sys-utils/setpriv.c:468
msgid "setresgid failed"
msgstr "setresgid 失败"

#: sys-utils/setpriv.c:500
#, fuzzy
msgid "unsupported capability type"
msgstr "不支持的时间类型"

#: sys-utils/setpriv.c:517
msgid "bad capability string"
msgstr "错误的权能字符串"

#: sys-utils/setpriv.c:525
msgid "libcap-ng is too old for \"all\" caps"
msgstr "对于“all”权能，libcap-ng 太旧"

#: sys-utils/setpriv.c:537
#, c-format
msgid "unknown capability \"%s\""
msgstr "未知权能“%s”"

#: sys-utils/setpriv.c:561
msgid "unrecognized securebit set -- refusing to adjust"
msgstr "无法识别的安全位集 -- 拒绝调整"

#: sys-utils/setpriv.c:565
msgid "bad securebits string"
msgstr "安全位字符串有误"

#: sys-utils/setpriv.c:572
msgid "+all securebits is not allowed"
msgstr "+all 安全位是不允许的"

#: sys-utils/setpriv.c:585
msgid "adjusting keep_caps does not make sense"
msgstr "调整 keep_caps(保持权能) 没有意义"

#: sys-utils/setpriv.c:589
msgid "unrecognized securebit"
msgstr "无法识别的安全位"

#: sys-utils/setpriv.c:609
msgid "SELinux is not running"
msgstr "SELinux 没有运行"

#: sys-utils/setpriv.c:624
#, c-format
msgid "close failed: %s"
msgstr "关闭失败：%s"

#: sys-utils/setpriv.c:632
msgid "AppArmor is not running"
msgstr "AppArmor 没有运行"

#: sys-utils/setpriv.c:775
msgid "duplicate --no-new-privs option"
msgstr "复制 --no-new-privs 选项"

#: sys-utils/setpriv.c:780
msgid "duplicate ruid"
msgstr "复制 ruid"

#: sys-utils/setpriv.c:782
msgid "failed to parse ruid"
msgstr "解析 ruid 失败"

#: sys-utils/setpriv.c:790
msgid "duplicate euid"
msgstr "复制 euid"

#: sys-utils/setpriv.c:792
msgid "failed to parse euid"
msgstr "解析 euid 失败"

#: sys-utils/setpriv.c:796
msgid "duplicate ruid or euid"
msgstr "复制 ruid 或 euid"

#: sys-utils/setpriv.c:798
msgid "failed to parse reuid"
msgstr "解析 reuid 失败"

#: sys-utils/setpriv.c:807
msgid "duplicate rgid"
msgstr "复制 rgid"

#: sys-utils/setpriv.c:809
msgid "failed to parse rgid"
msgstr "解析 rgid 失败"

#: sys-utils/setpriv.c:813
msgid "duplicate egid"
msgstr "复制 egid"

#: sys-utils/setpriv.c:815
msgid "failed to parse egid"
msgstr "解析 egid 失败"

#: sys-utils/setpriv.c:819
msgid "duplicate rgid or egid"
msgstr "复制 rgid 或 egid"

#: sys-utils/setpriv.c:821
msgid "failed to parse regid"
msgstr "解析 regid 失败"

#: sys-utils/setpriv.c:826
msgid "duplicate --clear-groups option"
msgstr "复制  --clear-groups 选项"

#: sys-utils/setpriv.c:832
msgid "duplicate --keep-groups option"
msgstr "复制 --keep-groups 选项"

#: sys-utils/setpriv.c:838
#, fuzzy
msgid "duplicate --init-groups option"
msgstr "复制 --groups 选项"

#: sys-utils/setpriv.c:844
msgid "duplicate --groups option"
msgstr "复制 --groups 选项"

#: sys-utils/setpriv.c:853
msgid "duplicate --inh-caps option"
msgstr "复制 --inh-caps 选项"

#: sys-utils/setpriv.c:859
#, fuzzy
msgid "duplicate --ambient-caps option"
msgstr "复制 --inh-caps 选项"

#: sys-utils/setpriv.c:865
msgid "duplicate --bounding-set option"
msgstr "复制 --bounding-set 选项"

#: sys-utils/setpriv.c:871
msgid "duplicate --securebits option"
msgstr "复制 --securebits 选项"

#: sys-utils/setpriv.c:877
msgid "duplicate --selinux-label option"
msgstr "复制 --selinux-label 选项"

#: sys-utils/setpriv.c:883
msgid "duplicate --apparmor-profile option"
msgstr "复制 --apparmor-profile 选项"

#: sys-utils/setpriv.c:899
msgid "--dump is incompatible with all other options"
msgstr "--dump 与其他所有选项不兼容"

#: sys-utils/setpriv.c:907
msgid "--list-caps must be specified alone"
msgstr "--list-caps 必须作为单独选项指定"

#: sys-utils/setpriv.c:913
msgid "No program specified"
msgstr "未指定程序"

#: sys-utils/setpriv.c:919
#, fuzzy
msgid "--[re]gid requires --keep-groups, --clear-groups, --init-groups, or --groups"
msgstr "--[re]gid 需要 --keep-groups、--clear-groups 或 --groups"

#: sys-utils/setpriv.c:923
msgid "--init-groups requires --ruid or --reuid"
msgstr ""

#: sys-utils/setpriv.c:927
#, c-format
msgid "uid %ld not found, --init-groups requires an user that can be found on the system"
msgstr ""

#: sys-utils/setpriv.c:932
msgid "disallow granting new privileges failed"
msgstr "禁止赋予新权限失败"

#: sys-utils/setpriv.c:940
msgid "keep process capabilities failed"
msgstr "保持进程权能失败"

#: sys-utils/setpriv.c:948
msgid "activate capabilities"
msgstr "激活权能"

#: sys-utils/setpriv.c:954
msgid "reactivate capabilities"
msgstr "重新激活权能"

#: sys-utils/setpriv.c:965
#, fuzzy
msgid "initgroups failed"
msgstr "setgroups 失败"

#: sys-utils/setpriv.c:973
msgid "set process securebits failed"
msgstr "设置进程安全位失败"

#: sys-utils/setpriv.c:979
msgid "apply bounding set"
msgstr "应用绑定集"

#: sys-utils/setpriv.c:985
msgid "apply capabilities"
msgstr "应用权能"

#: sys-utils/setsid.c:33
#, c-format
msgid " %s [options] <program> [arguments ...]\n"
msgstr " %s [选项] <程序> [参数 ...]\n"

#: sys-utils/setsid.c:37
msgid "Run a program in a new session.\n"
msgstr "在新会话中运行程序。\n"

#: sys-utils/setsid.c:40
msgid " -c, --ctty     set the controlling terminal to the current one\n"
msgstr " -c, --ctty     将控制终端设置为当前终端\n"

#: sys-utils/setsid.c:41
#, fuzzy
msgid " -f, --fork     always fork\n"
msgstr " -f, --force      强制检查\n"

#: sys-utils/setsid.c:42
msgid " -w, --wait     wait program to exit, and use the same return\n"
msgstr " -w, --wait     等待程序退出，并使用它的返回值\n"

#: sys-utils/setsid.c:100
msgid "fork"
msgstr "fork"

#: sys-utils/setsid.c:112
#, c-format
msgid "child %d did not exit normally"
msgstr "子 %d 未正常退出"

#: sys-utils/setsid.c:117
msgid "setsid failed"
msgstr "setsid 失败"

#: sys-utils/setsid.c:120
msgid "failed to set the controlling terminal"
msgstr "设置控制终端失败"

#: sys-utils/swapoff.c:85
#, c-format
msgid "swapoff %s\n"
msgstr "swapoff %s\n"

#: sys-utils/swapoff.c:104
msgid "Not superuser."
msgstr "非超级用户。"

#: sys-utils/swapoff.c:107
#, c-format
msgid "%s: swapoff failed"
msgstr "%s：swapoff 失败"

#: sys-utils/swapoff.c:122 sys-utils/swapon.c:794
#, c-format
msgid " %s [options] [<spec>]\n"
msgstr " %s [选项] [<指定>]\n"

#: sys-utils/swapoff.c:125
msgid "Disable devices and files for paging and swapping.\n"
msgstr "禁止将设备和文件用于分页和交换。\n"

#: sys-utils/swapoff.c:128
msgid ""
" -a, --all              disable all swaps from /proc/swaps\n"
" -v, --verbose          verbose mode\n"
msgstr ""
" -a, --all              禁用 /proc/swaps 中的所有交换区\n"
" -v, --verbose          verbose mode\n"

#: sys-utils/swapoff.c:134
msgid ""
"\n"
"The <spec> parameter:\n"
" -L <label>             LABEL of device to be used\n"
" -U <uuid>              UUID of device to be used\n"
" LABEL=<label>          LABEL of device to be used\n"
" UUID=<uuid>            UUID of device to be used\n"
" <device>               name of device to be used\n"
" <file>                 name of file to be used\n"
msgstr ""
"\n"
" <指定>参数包括：\n"
" -L <标签>              要使用设备的标签\n"
" -U <uuid>              要使用设备的 UUID\n"
" LABEL=<标签>           要使用设备的标签\n"
" UUID=<uuid>            要使用设备的 UUID\n"
" <设备>                 要使用设备的名称\n"
" <文件>                 要使用文件的名称\n"

#: sys-utils/swapon.c:96
msgid "device file or partition path"
msgstr "设备文件或分区路径"

#: sys-utils/swapon.c:97
msgid "type of the device"
msgstr "设备的类型"

#: sys-utils/swapon.c:98
msgid "size of the swap area"
msgstr "交换区大小"

#: sys-utils/swapon.c:99
msgid "bytes in use"
msgstr "已使用字节数"

#: sys-utils/swapon.c:100
msgid "swap priority"
msgstr "交换优先级"

#: sys-utils/swapon.c:101
msgid "swap uuid"
msgstr "swap uuid"

#: sys-utils/swapon.c:102
msgid "swap label"
msgstr "swap 标签"

#: sys-utils/swapon.c:250
#, c-format
msgid "%s\t\t\t\tType\t\tSize\tUsed\tPriority\n"
msgstr "%s\t\t\t\t类型\t\t大小\t已用\t权限\n"

#: sys-utils/swapon.c:250
msgid "Filename"
msgstr "文件名"

#: sys-utils/swapon.c:316
#, c-format
msgid "%s: reinitializing the swap."
msgstr "%s：正在重新初始化交换区。"

#: sys-utils/swapon.c:380
#, c-format
msgid "%s: lseek failed"
msgstr "%s：lseek 失败"

#: sys-utils/swapon.c:386
#, c-format
msgid "%s: write signature failed"
msgstr "%s：写签名失败"

#: sys-utils/swapon.c:540
#, c-format
msgid "%s: skipping - it appears to have holes."
msgstr "%s：将跳过 - 它似乎有空洞。"

#: sys-utils/swapon.c:548
#, c-format
msgid "%s: get size failed"
msgstr "%s：获取大小失败"

#: sys-utils/swapon.c:554
#, c-format
msgid "%s: read swap header failed"
msgstr "%s：读交换区头失败"

#: sys-utils/swapon.c:559
#, c-format
msgid "%s: found signature [pagesize=%d, signature=%s]"
msgstr "%s：找到签名[页尺寸=%d, 签名=%s]"

#: sys-utils/swapon.c:570
#, c-format
msgid "%s: pagesize=%d, swapsize=%llu, devsize=%llu"
msgstr "%s：页大小=%d，交换区大小=%llu，设备大小=%llu"

#: sys-utils/swapon.c:575
#, c-format
msgid "%s: last_page 0x%08llx is larger than actual size of swapspace"
msgstr "%s：末页 0x%08llx 大于交换空间的实际大小"

#: sys-utils/swapon.c:585
#, c-format
msgid "%s: swap format pagesize does not match."
msgstr "%s：交换格式 页大小 不匹配。"

#: sys-utils/swapon.c:591
#, c-format
msgid "%s: swap format pagesize does not match. (Use --fixpgsz to reinitialize it.)"
msgstr "%s：交换格式 页大小 不匹配。(使用 --fixpgsz 来重新对它初始化。)"

#: sys-utils/swapon.c:600
#, c-format
msgid "%s: software suspend data detected. Rewriting the swap signature."
msgstr "%s：检测到软件挂起数据。将重新写交换签名。"

#: sys-utils/swapon.c:670
#, c-format
msgid "swapon %s\n"
msgstr "swapon %s\n"

#: sys-utils/swapon.c:674
#, c-format
msgid "%s: swapon failed"
msgstr "%s：swapon 失败"

#: sys-utils/swapon.c:747
#, c-format
msgid "%s: noauto option -- ignored"
msgstr "%s：无自动选项 -- 已忽略"

#: sys-utils/swapon.c:769
#, c-format
msgid "%s: already active -- ignored"
msgstr "%s：已激活 -- 已忽略"

#: sys-utils/swapon.c:775
#, c-format
msgid "%s: inaccessible -- ignored"
msgstr "%s：无法访问 -- 已忽略"

#: sys-utils/swapon.c:797
msgid "Enable devices and files for paging and swapping.\n"
msgstr "允许将设备和文件用于分页和交换。\n"

#: sys-utils/swapon.c:800
msgid " -a, --all                enable all swaps from /etc/fstab\n"
msgstr " -a, --all                启用 /etc/fstab 中的所有交换区\n"

#: sys-utils/swapon.c:801
msgid " -d, --discard[=<policy>] enable swap discards, if supported by device\n"
msgstr " -d, --discard[=<policy>] 如果设备支持，启用 swap 丢弃\n"

#: sys-utils/swapon.c:802
msgid " -e, --ifexists           silently skip devices that do not exist\n"
msgstr " -e, --ifexists           自动跳过不存在的设备而不提示\n"

#: sys-utils/swapon.c:803
msgid " -f, --fixpgsz            reinitialize the swap space if necessary\n"
msgstr " -f, --fixpgsz            必要时重新初始化交换区\n"

#: sys-utils/swapon.c:804
msgid " -o, --options <list>     comma-separated list of swap options\n"
msgstr " -o, --options <列表>     以英文逗号分隔的 swap 选项\n"

#: sys-utils/swapon.c:805
msgid " -p, --priority <prio>    specify the priority of the swap device\n"
msgstr " -p, --priority <优先级>  指定交换设备的优先级\n"

#: sys-utils/swapon.c:806
msgid " -s, --summary            display summary about used swap devices (DEPRECATED)\n"
msgstr " -s, --summary            显示已使用交换设备的摘要(已废弃)\n"

#: sys-utils/swapon.c:807
msgid "     --show[=<columns>]   display summary in definable table\n"
msgstr "     --show[=<列>]        以可自定义的表格形式打印摘要\n"

#: sys-utils/swapon.c:808
msgid "     --noheadings         don't print table heading (with --show)\n"
msgstr "     --noheadings         不打印表头(与 --show 合用)\n"

#: sys-utils/swapon.c:809
msgid "     --raw                use the raw output format (with --show)\n"
msgstr "     --raw                使用原生输出格式(与 --show 合用)\n"

#: sys-utils/swapon.c:810
msgid "     --bytes              display swap size in bytes in --show output\n"
msgstr "     --bytes              在 --show 输出中以字节数显示交换区大小\n"

#: sys-utils/swapon.c:811
msgid " -v, --verbose            verbose mode\n"
msgstr " -v, --verbose                 详尽模式\n"

#: sys-utils/swapon.c:816
msgid ""
"\n"
"The <spec> parameter:\n"
" -L <label>             synonym for LABEL=<label>\n"
" -U <uuid>              synonym for UUID=<uuid>\n"
" LABEL=<label>          specifies device by swap area label\n"
" UUID=<uuid>            specifies device by swap area UUID\n"
" PARTLABEL=<label>      specifies device by partition label\n"
" PARTUUID=<uuid>        specifies device by partition UUID\n"
" <device>               name of device to be used\n"
" <file>                 name of file to be used\n"
msgstr ""
"\n"
"<spec> 参数：\n"
" -L <标签>              同 LABEL=<标签>\n"
" -U <uuid>              同 UUID=<uuid>\n"
" LABEL=<标签>           按交换区标签指定设备\n"
" UUID=<uuid>            按交换区 UUID 指定设备\n"
" PARTLABEL=<标签>       按分区标签指定设备\n"
" PARTUUID=<uuid>        按分区 UUID 指定设备\n"
" <设备>                 要使用设备的名称\n"
" <文件>                 要使用文件的名称\n"

#: sys-utils/swapon.c:826
msgid ""
"\n"
"Available discard policy types (for --discard):\n"
" once    : only single-time area discards are issued\n"
" pages   : freed pages are discarded before they are reused\n"
"If no policy is selected, both discard types are enabled (default).\n"
msgstr ""
"\n"
"可用的丢弃策略类型(针对 --discard)：\n"
" once\t  ：只进行单次区域丢弃(swapon)\n"
" pages\t  ：对释放的页在重新使用前丢弃\n"
" * 如果未选择策略，则两者都将启用。(默认)\n"

#: sys-utils/swapon.c:909
msgid "failed to parse priority"
msgstr "解析优先级失败"

#: sys-utils/swapon.c:928
#, c-format
msgid "unsupported discard policy: %s"
msgstr "不支持的丢弃策略：%s"

#: sys-utils/swapon-common.c:73
#, c-format
msgid "cannot find the device for %s"
msgstr "找不到对应 %s 的设备"

#: sys-utils/switch_root.c:60
msgid "failed to open directory"
msgstr "打开目录失败"

#: sys-utils/switch_root.c:68
msgid "stat failed"
msgstr "stat 失败"

#: sys-utils/switch_root.c:79
msgid "failed to read directory"
msgstr "读目录失败"

#: sys-utils/switch_root.c:116
#, c-format
msgid "failed to unlink %s"
msgstr "unlink %s 失败"

#: sys-utils/switch_root.c:153
#, c-format
msgid "failed to mount moving %s to %s"
msgstr "将 %s 挂载移动到 %s 失败"

#: sys-utils/switch_root.c:155
#, c-format
msgid "forcing unmount of %s"
msgstr "正在强制卸载 %s"

#: sys-utils/switch_root.c:161
#, c-format
msgid "failed to change directory to %s"
msgstr "将目录更改到 %s 失败"

#: sys-utils/switch_root.c:173
#, c-format
msgid "failed to mount moving %s to /"
msgstr "将 %s 挂载移动到 / 失败"

#: sys-utils/switch_root.c:179
msgid "failed to change root"
msgstr "更改 root 失败"

#: sys-utils/switch_root.c:192
msgid "old root filesystem is not an initramfs"
msgstr "旧根文件系统不是 initramfs 格式"

#: sys-utils/switch_root.c:205
#, c-format
msgid " %s [options] <newrootdir> <init> <args to init>\n"
msgstr " %s [选项] <新根目录> <init 程序> <init 程序参数>\n"

#: sys-utils/switch_root.c:209
msgid "Switch to another filesystem as the root of the mount tree.\n"
msgstr "切换到另一个文件系统作为挂载树的根目录。\n"

#: sys-utils/switch_root.c:255
msgid "failed. Sorry."
msgstr "失败了。抱歉。"

#: sys-utils/switch_root.c:258
#, c-format
msgid "cannot access %s"
msgstr "无法访问 %s"

#: sys-utils/tunelp.c:98
msgid "Set various parameters for the line printer.\n"
msgstr "设置行式打印机的各种参数。\n"

#: sys-utils/tunelp.c:101
msgid " -i, --irq <num>              specify parallel port irq\n"
msgstr " -i, --irq <数字>             指定并口中断号\n"

#: sys-utils/tunelp.c:102
msgid " -t, --time <ms>              driver wait time in milliseconds\n"
msgstr " -t, --time <毫秒数>          驱动等待时间(毫秒)\n"

#: sys-utils/tunelp.c:103
msgid " -c, --chars <num>            number of output characters before sleep\n"
msgstr " -c, --chars <数字>     睡眠前输出的字符数\n"

#: sys-utils/tunelp.c:104
msgid " -w, --wait <us>              strobe wait in micro seconds\n"
msgstr " -w, --wait <微秒数>          选通(strobe)信号等待时间(微秒)\n"

#. TRANSLATORS: do not translate <on|off> arguments. The
#. argument reader does not recognize locale, unless `on' is
#. exactly that very same string.
#: sys-utils/tunelp.c:108
msgid " -a, --abort <on|off>         abort on error\n"
msgstr " -a, --abort <on|off>         出错时中止\n"

#: sys-utils/tunelp.c:109
msgid " -o, --check-status <on|off>  check printer status before printing\n"
msgstr " -o, --check-status <on|off>  打印前检查打印机状态\n"

#: sys-utils/tunelp.c:110
msgid " -C, --careful <on|off>       extra checking to status check\n"
msgstr " -C, --careful <on|off>       进行状态检查外的其他检查\n"

#: sys-utils/tunelp.c:111
msgid " -s, --status                 query printer status\n"
msgstr " -s, --status                 查询打印机状态\n"

#: sys-utils/tunelp.c:112
msgid " -r, --reset                  reset the port\n"
msgstr " -r, --reset                  重置端口\n"

#: sys-utils/tunelp.c:113
msgid " -q, --print-irq <on|off>     display current irq setting\n"
msgstr " -q, --print-irq <on|off>     显示当前的中断设置\n"

#: sys-utils/tunelp.c:259
#, c-format
msgid "%s not an lp device"
msgstr "%s 不是循环设备"

#: sys-utils/tunelp.c:278
msgid "LPGETSTATUS error"
msgstr "LPGETSTATUS 出错"

#: sys-utils/tunelp.c:283
#, c-format
msgid "%s status is %d"
msgstr "%s 状态为 %d"

#: sys-utils/tunelp.c:285
#, c-format
msgid ", busy"
msgstr "，忙碌"

#: sys-utils/tunelp.c:287
#, c-format
msgid ", ready"
msgstr "，就绪"

#: sys-utils/tunelp.c:289
#, c-format
msgid ", out of paper"
msgstr "，缺页"

#: sys-utils/tunelp.c:291
#, c-format
msgid ", on-line"
msgstr "，在线"

#: sys-utils/tunelp.c:293
#, c-format
msgid ", error"
msgstr "，错误"

#: sys-utils/tunelp.c:298
msgid "ioctl failed"
msgstr "ioctl 失败"

#: sys-utils/tunelp.c:308
msgid "LPGETIRQ error"
msgstr "LPGETIRQ 出错"

#: sys-utils/tunelp.c:313
#, c-format
msgid "%s using IRQ %d\n"
msgstr "%s 使用中断请求 %d\n"

#: sys-utils/tunelp.c:315
#, c-format
msgid "%s using polling\n"
msgstr "%s 使用轮询\n"

#: sys-utils/umount.c:79
#, c-format
msgid ""
" %1$s [-hV]\n"
" %1$s -a [options]\n"
" %1$s [options] <source> | <directory>\n"
msgstr ""
" %1$s [-hV]\n"
" %1$s -a [选项]\n"
" %1$s [选项] <源> | <目录>\n"

#: sys-utils/umount.c:85
msgid "Unmount filesystems.\n"
msgstr "卸载文件系统。\n"

#: sys-utils/umount.c:88
msgid " -a, --all               unmount all filesystems\n"
msgstr " -a, --all               卸载所有文件系统\n"

#: sys-utils/umount.c:89
msgid ""
" -A, --all-targets       unmount all mountpoints for the given device in the\n"
"                           current namespace\n"
msgstr ""
" -A, --all-targets       卸载当前名字空间内指定设备\n"
"                         对应的所有挂臷点\n"

#: sys-utils/umount.c:91
msgid " -c, --no-canonicalize   don't canonicalize paths\n"
msgstr " -c, --no-canonicalize   不对路径规范化\n"

#: sys-utils/umount.c:92
msgid " -d, --detach-loop       if mounted loop device, also free this loop device\n"
msgstr " -d, --detach-loop       若挂臷了回环设备，也释放该回环设备\n"

#: sys-utils/umount.c:93
msgid "     --fake              dry run; skip the umount(2) syscall\n"
msgstr "     --fake              空运行；跳过 umount(2) 系统调用\n"

#: sys-utils/umount.c:94
msgid " -f, --force             force unmount (in case of an unreachable NFS system)\n"
msgstr " -f, --force             强制卸载(遇到不响应的 NFS 系统时)\n"

#: sys-utils/umount.c:95
msgid " -i, --internal-only     don't call the umount.<type> helpers\n"
msgstr " -i, --internal-only     不调用 umount.<类型> 辅助程序\n"

#: sys-utils/umount.c:97
msgid " -l, --lazy              detach the filesystem now, clean up things later\n"
msgstr " -l, --lazy              立即断开文件系统，清理以后执行\n"

#: sys-utils/umount.c:98
msgid " -O, --test-opts <list>  limit the set of filesystems (use with -a)\n"
msgstr " -O, --test-opts <列表>  限制文件系统集合(和 -a 选项一起使用)\n"

#: sys-utils/umount.c:99
msgid " -R, --recursive         recursively unmount a target with all its children\n"
msgstr " -R, --recursive         递归卸载目录及其子对象\n"

#: sys-utils/umount.c:100
msgid " -r, --read-only         in case unmounting fails, try to remount read-only\n"
msgstr " -r, --read-only         若卸载失败，尝试以只读方式重新挂臷\n"

#: sys-utils/umount.c:101
msgid " -t, --types <list>      limit the set of filesystem types\n"
msgstr " -t, --types <列表>      限制文件系统集合\n"

#: sys-utils/umount.c:145
#, c-format
msgid "%s (%s) unmounted"
msgstr "%s (%s) 已卸载"

#: sys-utils/umount.c:147
#, c-format
msgid "%s unmounted"
msgstr "%s 未挂载"

#: sys-utils/umount.c:207
msgid "failed to set umount target"
msgstr "设置卸载目标失败"

#: sys-utils/umount.c:223
msgid "libmount table allocation failed"
msgstr "libmount 表分配失败"

#: sys-utils/umount.c:266 sys-utils/umount.c:346
msgid "libmount iterator allocation failed"
msgstr "分配 libmount 迭代器失败！"

#: sys-utils/umount.c:272
#, c-format
msgid "failed to get child fs of %s"
msgstr "获取 %s 的子文件系统失败"

#: sys-utils/umount.c:310 sys-utils/umount.c:333
#, c-format
msgid "%s: not found"
msgstr "%s：找不到"

#: sys-utils/umount.c:340
#, c-format
msgid "%s: failed to determine source (--all-targets is unsupported on systems with regular mtab file)."
msgstr "%s：确定源失败(有常规 mtab 文件的系统不支持 --all-targets)"

#: sys-utils/unshare.c:91
#, c-format
msgid "unsupported --setgroups argument '%s'"
msgstr "不支持的 --setgroups 参数“%s”"

#: sys-utils/unshare.c:112 sys-utils/unshare.c:127
#, c-format
msgid "write failed %s"
msgstr "写失败：%s"

#: sys-utils/unshare.c:150
#, c-format
msgid "unsupported propagation mode: %s"
msgstr "不受支持的传播模式︰%s"

#: sys-utils/unshare.c:159
msgid "cannot change root filesystem propagation"
msgstr "无法更改根文件系统传播"

#: sys-utils/unshare.c:190
#, c-format
msgid "mount %s on %s failed"
msgstr "将 %s 挂载到 %s 失败"

#: sys-utils/unshare.c:204
#, c-format
msgid "cannot stat %s"
msgstr "无法 stat %s"

#: sys-utils/unshare.c:215
msgid "pipe failed"
msgstr "pipe 失败"

#: sys-utils/unshare.c:229
msgid "failed to read pipe"
msgstr "读取管道失败"

#: sys-utils/unshare.c:252
msgid "Run a program with some namespaces unshared from the parent.\n"
msgstr "以某些未与父(进程)共享的名字空间运行某个程序。\n"

#: sys-utils/unshare.c:255
msgid " -m, --mount[=<file>]      unshare mounts namespace\n"
msgstr " -m, --mount[=<文件>]      取消共享 mounts 名字空间\n"

#: sys-utils/unshare.c:256
msgid " -u, --uts[=<file>]        unshare UTS namespace (hostname etc)\n"
msgstr " -u, --uts[=<文件>]        取消共享 UTS 名字空间(主机名等)\n"

#: sys-utils/unshare.c:257
msgid " -i, --ipc[=<file>]        unshare System V IPC namespace\n"
msgstr " -i, --ipc[=<文件>]        取消共享 System V IPC 名字空间\n"

#: sys-utils/unshare.c:258
msgid " -n, --net[=<file>]        unshare network namespace\n"
msgstr " -n, --net[=<file>]        取消共享网络名字空间\n"

#: sys-utils/unshare.c:259
msgid " -p, --pid[=<file>]        unshare pid namespace\n"
msgstr " -p, --pid[=<文件>]        取消共享 pid 名字空间\n"

#: sys-utils/unshare.c:260
msgid " -U, --user[=<file>]       unshare user namespace\n"
msgstr " -U, --user[=<文件>]       取消共享用户名字空间\n"

#: sys-utils/unshare.c:261
msgid " -C, --cgroup[=<file>]     unshare cgroup namespace\n"
msgstr " -C, --cgroup[=<文件>]     取消共享 cgroup 名字空间\n"

#: sys-utils/unshare.c:262
msgid " -f, --fork                fork before launching <program>\n"
msgstr " -f, --fork                在启动<程序>前 fork\n"

#: sys-utils/unshare.c:263
msgid "     --kill-child[=<signame>]  when dying, kill the forked child (implies --fork); defaults to SIGKILL\n"
msgstr ""

#: sys-utils/unshare.c:264
msgid "     --mount-proc[=<dir>]  mount proc filesystem first (implies --mount)\n"
msgstr "     --mount-proc[=<目录>] 先挂载 proc 文件系统(连带打开 --mount)\n"

#: sys-utils/unshare.c:265
msgid " -r, --map-root-user       map current user to root (implies --user)\n"
msgstr " -r, --map-root-user       将当前用户映射为 root (连带打开 --user)\n"

#: sys-utils/unshare.c:266
msgid ""
"     --propagation slave|shared|private|unchanged\n"
"                           modify mount propagation in mount namespace\n"
msgstr ""
"     --propagation slave|shared|private|unchanged\n"
"                           修改 mount 名字空间中的 mount 传播\n"

#: sys-utils/unshare.c:268
msgid " -s, --setgroups allow|deny  control the setgroups syscall in user namespaces\n"
msgstr " -s, --setgroups allow|deny  控制用户名字空间中的 setgroups 系统调用\n"

#: sys-utils/unshare.c:401
msgid "unshare failed"
msgstr "unshare 失败"

#: sys-utils/unshare.c:445
msgid "child exit failed"
msgstr "子进程退出失败"

#: sys-utils/unshare.c:454
msgid "options --setgroups=allow and --map-root-user are mutually exclusive"
msgstr "--setgroups=allow 和 --map-root-user 选项是互斥的"

#: sys-utils/unshare.c:474
#, c-format
msgid "mount %s failed"
msgstr "挂载 %s 失败"

#: sys-utils/wdctl.c:73
msgid "Card previously reset the CPU"
msgstr "卡曾经重置 CPU"

#: sys-utils/wdctl.c:74
msgid "External relay 1"
msgstr "外部中继 1"

#: sys-utils/wdctl.c:75
msgid "External relay 2"
msgstr "外部中继 2"

#: sys-utils/wdctl.c:76
msgid "Fan failed"
msgstr "风扇失败"

#: sys-utils/wdctl.c:77
msgid "Keep alive ping reply"
msgstr "保持活动 ping 回应"

#: sys-utils/wdctl.c:78
msgid "Supports magic close char"
msgstr "支持 magic close 字符"

#: sys-utils/wdctl.c:79
msgid "Reset due to CPU overheat"
msgstr "因 CPU 过热重置"

#: sys-utils/wdctl.c:80
msgid "Power over voltage"
msgstr "供电电压过高"

#: sys-utils/wdctl.c:81
msgid "Power bad/power fault"
msgstr "供电问题/供电故障"

#: sys-utils/wdctl.c:82
msgid "Pretimeout (in seconds)"
msgstr "预超时(秒)"

#: sys-utils/wdctl.c:83
msgid "Set timeout (in seconds)"
msgstr "设置超时(秒)"

#: sys-utils/wdctl.c:84
msgid "Not trigger reboot"
msgstr "不触发重启"

#: sys-utils/wdctl.c:100
msgid "flag name"
msgstr "标志名称"

#: sys-utils/wdctl.c:101
msgid "flag description"
msgstr "标志描述"

#: sys-utils/wdctl.c:102
msgid "flag status"
msgstr "标志状态"

#: sys-utils/wdctl.c:103
msgid "flag boot status"
msgstr "标志启动状态"

#: sys-utils/wdctl.c:104
msgid "watchdog device name"
msgstr "看门狗设备名称"

#: sys-utils/wdctl.c:138
#, c-format
msgid "unknown flag: %s"
msgstr "未知标志：%s"

#: sys-utils/wdctl.c:178
msgid "Show the status of the hardware watchdog.\n"
msgstr "显示硬件看门狗的状态。\n"

#: sys-utils/wdctl.c:181
msgid ""
" -f, --flags <list>     print selected flags only\n"
" -F, --noflags          don't print information about flags\n"
" -I, --noident          don't print watchdog identity information\n"
" -n, --noheadings       don't print headings for flags table\n"
" -O, --oneline          print all information on one line\n"
" -o, --output <list>    output columns of the flags\n"
" -r, --raw              use raw output format for flags table\n"
" -T, --notimeouts       don't print watchdog timeouts\n"
" -s, --settimeout <sec> set watchdog timeout\n"
" -x, --flags-only       print only flags table (same as -I -T)\n"
msgstr ""
" -f, --flags <列表>     只打印选择的标志\n"
" -F, --noflags          不打印标志的相关信息\n"
" -I, --noident          不打印 watchdog 标识信息\n"
" -n, --noheadings       不打印标志表格的表头\n"
" -O, --oneline          将所有信息打印为一行\n"
" -o, --output <列表>    标志要输出的列\n"
" -r, --raw              标志表格使用原生输出格式\n"
" -T, --notimeouts       不打印看门狗超时\n"
" -s, --settimeout <秒>  设置看门狗超时\n"
" -x, --flags-only       只打印标志表格(同 -I -T)\n"

#: sys-utils/wdctl.c:196
#, c-format
msgid "The default device is %s.\n"
msgstr "默认设备为 %s。\n"

#: sys-utils/wdctl.c:290
#, c-format
msgid "%s: unknown flags 0x%x\n"
msgstr "%s：未知标志 0x%x\n"

#: sys-utils/wdctl.c:320 sys-utils/wdctl.c:376
#, c-format
msgid "%s: watchdog already in use, terminating."
msgstr "%s：看门狗正在使用，将终止。"

#: sys-utils/wdctl.c:334 sys-utils/wdctl.c:404
#, c-format
msgid "%s: failed to disarm watchdog"
msgstr "%s：喂看门狗失败"

#: sys-utils/wdctl.c:343
#, c-format
msgid "cannot set timeout for %s"
msgstr "无法设置 %s 的超时"

#: sys-utils/wdctl.c:349
#, c-format
msgid "Timeout has been set to %d second.\n"
msgid_plural "Timeout has been set to %d seconds.\n"
msgstr[0] "超时已调整为 %d 秒\n"

#: sys-utils/wdctl.c:383
#, c-format
msgid "%s: failed to get information about watchdog"
msgstr "%s：获取看门狗信息失败"

#: sys-utils/wdctl.c:465 sys-utils/wdctl.c:468 sys-utils/wdctl.c:471
#, c-format
msgid "%-14s %2i second\n"
msgid_plural "%-14s %2i seconds\n"
msgstr[0] "%-14s %2i 秒\n"

#: sys-utils/wdctl.c:466
msgid "Timeout:"
msgstr "超时："

#: sys-utils/wdctl.c:469
msgid "Pre-timeout:"
msgstr "预超时："

#: sys-utils/wdctl.c:472
msgid "Timeleft:"
msgstr "剩余时间："

#: sys-utils/wdctl.c:604
msgid "Device:"
msgstr "设备："

#: sys-utils/wdctl.c:606
msgid "Identity:"
msgstr "标识："

#: sys-utils/wdctl.c:608
msgid "version"
msgstr "版本："

#: sys-utils/zramctl.c:75
msgid "zram device name"
msgstr "zram 设备名称"

#: sys-utils/zramctl.c:76
msgid "limit on the uncompressed amount of data"
msgstr "对未压缩数据量的限制"

#: sys-utils/zramctl.c:77
msgid "uncompressed size of stored data"
msgstr "存储数据的未压缩大小"

#: sys-utils/zramctl.c:78
msgid "compressed size of stored data"
msgstr "存储数据的压缩后大小"

#: sys-utils/zramctl.c:79
msgid "the selected compression algorithm"
msgstr "所选的压缩算法"

#: sys-utils/zramctl.c:80
msgid "number of concurrent compress operations"
msgstr "并发的压缩操作的数量"

#: sys-utils/zramctl.c:81
msgid "empty pages with no allocated memory"
msgstr "未分配内存的空页"

#: sys-utils/zramctl.c:82
msgid "all memory including allocator fragmentation and metadata overhead"
msgstr "包括分配器碎片和元数据开销在内的所有内存"

#: sys-utils/zramctl.c:83
msgid "memory limit used to store compressed data"
msgstr "用于存储压缩后数据的内存限制"

#: sys-utils/zramctl.c:84
msgid "memory zram have been consumed to store compressed data"
msgstr "已消耗内存 zram 来存储压缩的数据"

#: sys-utils/zramctl.c:85
msgid "number of objects migrated by compaction"
msgstr "通过压实迁移的对象数"

#: sys-utils/zramctl.c:376
msgid "Failed to parse mm_stat"
msgstr "解析 mm_stat 失败"

#: sys-utils/zramctl.c:532
#, c-format
msgid ""
" %1$s [options] <device>\n"
" %1$s -r <device> [...]\n"
" %1$s [options] -f | <device> -s <size>\n"
msgstr ""
" %1$s [选项] [<回环设备>]\n"
" %1$s [选项] -f | <回环设备> <文件>\n"

#: sys-utils/zramctl.c:538
msgid "Set up and control zram devices.\n"
msgstr "设置和控制 zram 设备。\n"

#: sys-utils/zramctl.c:541
#, fuzzy
msgid " -a, --algorithm lzo|lz4|lz4hc|deflate|842   compression algorithm to use\n"
msgstr " -a, --algorithm lzo|lz4   要使用的压缩算法\n"

#: sys-utils/zramctl.c:542
msgid " -b, --bytes               print sizes in bytes rather than in human readable format\n"
msgstr " -b, --bytes               以字节为打印尺寸，而非易读格式\n"

#: sys-utils/zramctl.c:543
msgid " -f, --find                find a free device\n"
msgstr " -f, --find                查找空闲设备\n"

#: sys-utils/zramctl.c:544
msgid " -n, --noheadings          don't print headings\n"
msgstr " -n, --noheadings          不打印标题\n"

#: sys-utils/zramctl.c:545
msgid " -o, --output <list>       columns to use for status output\n"
msgstr " -o, --output <list>       用于状态输出的列\n"

#: sys-utils/zramctl.c:546
msgid "     --raw                 use raw status output format\n"
msgstr "     --raw                 使用原生状态输出格式\n"

#: sys-utils/zramctl.c:547
msgid " -r, --reset               reset all specified devices\n"
msgstr " -r, --reset               重置所有指定的设备\n"

#: sys-utils/zramctl.c:548
msgid " -s, --size <size>         device size\n"
msgstr " -s, --size <尺寸>         设备尺寸\n"

#: sys-utils/zramctl.c:549
msgid " -t, --streams <number>    number of compression streams\n"
msgstr " -t, --streams <数字>      压缩流数量\n"

#: sys-utils/zramctl.c:633
msgid "failed to parse streams"
msgstr "解析流失败"

#: sys-utils/zramctl.c:655
msgid "option --find is mutually exclusive with <device>"
msgstr "--find 选项与<设备>互斥"

#: sys-utils/zramctl.c:661
msgid "only one <device> at a time is allowed"
msgstr "一次只允许一个 <设备>"

#: sys-utils/zramctl.c:664
msgid "options --algorithm and --streams must be combined with --size"
msgstr "--algorithm 和 --streams 必须与 --size 合用"

#: sys-utils/zramctl.c:694 sys-utils/zramctl.c:723
#, c-format
msgid "%s: failed to reset"
msgstr "%s︰重置失败"

#: sys-utils/zramctl.c:705 sys-utils/zramctl.c:713
msgid "no free zram device found"
msgstr "未找到空闲的 zram 设备"

#: sys-utils/zramctl.c:727
#, c-format
msgid "%s: failed to set number of streams"
msgstr "%s︰设置流数量失败"

#: sys-utils/zramctl.c:731
#, c-format
msgid "%s: failed to set algorithm"
msgstr "%s︰设置算法失败"

#: sys-utils/zramctl.c:734
#, c-format
msgid "%s: failed to set disksize (%ju bytes)"
msgstr "%s：设置磁盘大小失败(%ju 个字节)"

#: term-utils/agetty.c:470
#, c-format
msgid "%s%s (automatic login)\n"
msgstr "%s%s (自动登录)\n"

#: term-utils/agetty.c:526
#, c-format
msgid "%s: can't change root directory %s: %m"
msgstr "%s：无法更改根目录 %s：%m"

#: term-utils/agetty.c:529
#, c-format
msgid "%s: can't change working directory %s: %m"
msgstr "%s：无法更改工作目录 %s：%m"

#: term-utils/agetty.c:532
#, c-format
msgid "%s: can't change process priority: %m"
msgstr "%s：无法更改进程优先级：%m"

#: term-utils/agetty.c:543
#, c-format
msgid "%s: can't exec %s: %m"
msgstr "%s：无法执行 %s：%m"

#: term-utils/agetty.c:574 term-utils/agetty.c:901 term-utils/agetty.c:1419
#: term-utils/agetty.c:1437 term-utils/agetty.c:1474 term-utils/agetty.c:1484
#: term-utils/agetty.c:1526 term-utils/agetty.c:2093 term-utils/agetty.c:2655
#, c-format
msgid "failed to allocate memory: %m"
msgstr "分配内存失败：%m"

#: term-utils/agetty.c:664
#, fuzzy, c-format
msgid "%s from %s"
msgstr "%s，来自 %s\n"

#: term-utils/agetty.c:748
msgid "invalid delay argument"
msgstr "无效的延迟参数"

#: term-utils/agetty.c:786
msgid "invalid argument of --local-line"
msgstr "--local-line 选项参数无效"

#: term-utils/agetty.c:805
msgid "invalid nice argument"
msgstr "无效的 nice 参数"

#: term-utils/agetty.c:906
#, c-format
msgid "bad speed: %s"
msgstr "速度有误：%s"

#: term-utils/agetty.c:908
msgid "too many alternate speeds"
msgstr "备选速度过多"

#: term-utils/agetty.c:1015 term-utils/agetty.c:1019 term-utils/agetty.c:1072
#, c-format
msgid "/dev/%s: cannot open as standard input: %m"
msgstr "/dev/%s：无法以标准输入打开：%m"

#: term-utils/agetty.c:1038
#, c-format
msgid "/dev/%s: not a character device"
msgstr "/dev/%s：不是字符设备"

#: term-utils/agetty.c:1040
#, c-format
msgid "/dev/%s: not a tty"
msgstr "/dev/%s：不是终端"

#: term-utils/agetty.c:1044 term-utils/agetty.c:1076
#, c-format
msgid "/dev/%s: cannot get controlling tty: %m"
msgstr "/dev/%s：无法获取控制 tty：%m"

#: term-utils/agetty.c:1066
#, c-format
msgid "/dev/%s: vhangup() failed: %m"
msgstr "/dev/%s：vhangup() 失败：%m"

#: term-utils/agetty.c:1087
#, c-format
msgid "%s: not open for read/write"
msgstr "%s：未打开(就)读/写"

#: term-utils/agetty.c:1092
#, c-format
msgid "/dev/%s: cannot set process group: %m"
msgstr "/dev/%s：无法设置进程组：%m"

#: term-utils/agetty.c:1106
#, c-format
msgid "%s: dup problem: %m"
msgstr "%s：dup 问题：%m"

#: term-utils/agetty.c:1123
#, c-format
msgid "%s: failed to get terminal attributes: %m"
msgstr "%s：获取终端属性失败：%m"

#: term-utils/agetty.c:1325 term-utils/agetty.c:1345
#, c-format
msgid "setting terminal attributes failed: %m"
msgstr "设置终端属性失败：%m"

#: term-utils/agetty.c:1464
msgid "cannot open os-release file"
msgstr "无法打开 os-release 文件"

#: term-utils/agetty.c:1631
#, c-format
msgid "failed to create reload file: %s: %m"
msgstr "未能创建 reload 文件︰%s：%m"

#: term-utils/agetty.c:1835
msgid "[press ENTER to login]"
msgstr "[按 ENTER 键登录]"

#: term-utils/agetty.c:1859
msgid "Num Lock off"
msgstr "Num Lock 关"

#: term-utils/agetty.c:1862
msgid "Num Lock on"
msgstr "Num Lock 开"

#: term-utils/agetty.c:1865
msgid "Caps Lock on"
msgstr "Caps Lock 开"

#: term-utils/agetty.c:1868
msgid "Scroll Lock on"
msgstr "Scroll Lock 开"

#: term-utils/agetty.c:1871
#, c-format
msgid ""
"Hint: %s\n"
"\n"
msgstr ""
"提示：%s\n"
"\n"

#: term-utils/agetty.c:2008
#, c-format
msgid "%s: read: %m"
msgstr "%s：read：%m"

#: term-utils/agetty.c:2072
#, c-format
msgid "%s: input overrun"
msgstr "%s：输入过载"

#: term-utils/agetty.c:2089 term-utils/agetty.c:2097
#, c-format
msgid "%s: invalid character conversion for login name"
msgstr "%s：登录名字符转换无效"

#: term-utils/agetty.c:2103
#, c-format
msgid "%s: invalid character 0x%x in login name"
msgstr "%s：登录名中的字符 0x%x 无效"

#: term-utils/agetty.c:2188
#, c-format
msgid "%s: failed to set terminal attributes: %m"
msgstr "%s：设置终端属性失败：%m"

#: term-utils/agetty.c:2226
#, c-format
msgid ""
" %1$s [options] <line> [<baud_rate>,...] [<termtype>]\n"
" %1$s [options] <baud_rate>,... <line> [<termtype>]\n"
msgstr ""
" %1$s [选项] <线路> [<波特率>,...] [<终端类型>]\n"
" %1$s [选项] <波特率>,... <线路> [<终端类型>]\n"

#: term-utils/agetty.c:2230
msgid "Open a terminal and set its mode.\n"
msgstr "打开一个终端并设置其模式。\n"

#: term-utils/agetty.c:2233
msgid " -8, --8bits                assume 8-bit tty\n"
msgstr " -8, --8bits                采用 8 位 tty\n"

#: term-utils/agetty.c:2234
msgid " -a, --autologin <user>     login the specified user automatically\n"
msgstr " -a, --autologin <用户>     以指定用户自动登录\n"

#: term-utils/agetty.c:2235
msgid " -c, --noreset              do not reset control mode\n"
msgstr " -c, --noreset              不重置控制模式\n"

#: term-utils/agetty.c:2236
msgid " -E, --remote               use -r <hostname> for login(1)\n"
msgstr " -E, --remote               使用 -r <主机名> 选项调用 login(1)\n"

#: term-utils/agetty.c:2237
msgid " -f, --issue-file <file>    display issue file\n"
msgstr " -f, --issue-file <文件>    指定要显示的预登录消息(issue)文件\n"

#: term-utils/agetty.c:2238
msgid " -h, --flow-control         enable hardware flow control\n"
msgstr " -h, --flow-control         启用硬件流控制\n"

#: term-utils/agetty.c:2239
msgid " -H, --host <hostname>      specify login host\n"
msgstr " -H, --host <主机名>        指定登录主机\n"

#: term-utils/agetty.c:2240
msgid " -i, --noissue              do not display issue file\n"
msgstr " -i, --noissue              不显示预登录消息(issue)文件\n"

#: term-utils/agetty.c:2241
msgid " -I, --init-string <string> set init string\n"
msgstr " -I, --init-string <字符串> 设置初始字符串\n"

#: term-utils/agetty.c:2242
msgid " -J  --noclear              do not clear the screen before prompt\n"
msgstr " -J  --noclear              提示之前不清屏\n"

#: term-utils/agetty.c:2243
msgid " -l, --login-program <file> specify login program\n"
msgstr " -l, --login-program <文件> 指定登录程序\n"

#: term-utils/agetty.c:2244
msgid " -L, --local-line[=<mode>]  control the local line flag\n"
msgstr " -L, --local-line[=<模式>]  控制本地线路标志\n"

#: term-utils/agetty.c:2245
msgid " -m, --extract-baud         extract baud rate during connect\n"
msgstr " -m, --extract-baud         连接过程中提取波特率\n"

#: term-utils/agetty.c:2246
msgid " -n, --skip-login           do not prompt for login\n"
msgstr " -n, --skip-login           不提示登录\n"

#: term-utils/agetty.c:2247
msgid " -N  --nonewline            do not print a newline before issue\n"
msgstr " -N  --nonewline            预登录消息(issue)前不打印换行(newline)\n"

#: term-utils/agetty.c:2248
msgid " -o, --login-options <opts> options that are passed to login\n"
msgstr " -o, --login-options <选项> 传递给登录程序的选项\n"

#: term-utils/agetty.c:2249
msgid " -p, --login-pause          wait for any key before the login\n"
msgstr " -p, --login-pause          登录前等待按下任意键来继续\n"

#: term-utils/agetty.c:2250
msgid " -r, --chroot <dir>         change root to the directory\n"
msgstr " -r, --chroot <目录>        将根目录更改为指定目录\n"

#: term-utils/agetty.c:2251
msgid " -R, --hangup               do virtually hangup on the tty\n"
msgstr " -R, --hangup               对 tty 执行虚拟挂起(virtual hangup)\n"

#: term-utils/agetty.c:2252
msgid " -s, --keep-baud            try to keep baud rate after break\n"
msgstr " -s, --keep-baud            中断(break)后尝试保持波特率\n"

#: term-utils/agetty.c:2253
msgid " -t, --timeout <number>     login process timeout\n"
msgstr " -t, --timeout <数字>       登录进程超时(秒)\n"

#: term-utils/agetty.c:2254
msgid " -U, --detect-case          detect uppercase terminal\n"
msgstr " -U, --detect-case          检测纯大写终端\n"

#: term-utils/agetty.c:2255
msgid " -w, --wait-cr              wait carriage-return\n"
msgstr " -w, --wait-cr              等待回车\n"

#: term-utils/agetty.c:2256
msgid "     --nohints              do not print hints\n"
msgstr "     --nohints              不打印提示信息\n"

#: term-utils/agetty.c:2257
msgid "     --nohostname           no hostname at all will be shown\n"
msgstr "     --nohostname           将完全不显示主机名\n"

#: term-utils/agetty.c:2258
msgid "     --long-hostname        show full qualified hostname\n"
msgstr "     --long-hostname        显示完全限定主机名\n"

#: term-utils/agetty.c:2259
msgid "     --erase-chars <string> additional backspace chars\n"
msgstr "     --erase-chars <字符串> 附加的退格字符\n"

#: term-utils/agetty.c:2260
msgid "     --kill-chars <string>  additional kill chars\n"
msgstr "     --kill-chars <字符串>  附加的杀死(kill)字符\n"

#: term-utils/agetty.c:2261
msgid "     --chdir <directory>    chdir before the login\n"
msgstr "     --chdir <目录>         登录前切换目录(chdir)\n"

#: term-utils/agetty.c:2262
msgid "     --delay <number>       sleep seconds before prompt\n"
msgstr "     --delay <数字>         提示前睡眠的秒数\n"

#: term-utils/agetty.c:2263
msgid "     --nice <number>        run login with this priority\n"
msgstr "     --nice <数字>          以指定优先级运行 login\n"

#: term-utils/agetty.c:2264
msgid "     --reload               reload prompts on running agetty instances\n"
msgstr "     --reload               在运行 agetty 实例时重新载入提示\n"

#: term-utils/agetty.c:2265
#, fuzzy
msgid "     --list-speeds          display supported baud rates\n"
msgstr "     --list               列出可设置的架构并退出\n"

#: term-utils/agetty.c:2615
#, c-format
msgid "%d user"
msgid_plural "%d users"
msgstr[0] "%d 位用户"

#: term-utils/agetty.c:2743
#, c-format
msgid "checkname failed: %m"
msgstr "checkname 失败：%m"

#: term-utils/agetty.c:2755
#, c-format
msgid "cannot touch file %s"
msgstr "无法 touch 文件 %s"

#: term-utils/agetty.c:2759
msgid "--reload is unsupported on your system"
msgstr "您的系统不支持 --reload"

#: term-utils/mesg.c:76
#, c-format
msgid " %s [options] [y | n]\n"
msgstr " %s [选项] [y | n]\n"

#: term-utils/mesg.c:79
msgid "Control write access of other users to your terminal.\n"
msgstr "控制其他用户对您终端的写权限。\n"

#: term-utils/mesg.c:82
msgid " -v, --verbose  explain what is being done\n"
msgstr " -v, --verbose  解释正在进行的操作\n"

#: term-utils/mesg.c:125
msgid "ttyname failed"
msgstr "ttyname 失败"

#: term-utils/mesg.c:134
msgid "is y"
msgstr "是 y"

#: term-utils/mesg.c:137
msgid "is n"
msgstr "是 n"

#: term-utils/mesg.c:148 term-utils/mesg.c:155
#, c-format
msgid "change %s mode failed"
msgstr "更改 %s 模式失败"

#: term-utils/mesg.c:150
msgid "write access to your terminal is allowed"
msgstr "允许了写您的终端"

#: term-utils/mesg.c:157
msgid "write access to your terminal is denied"
msgstr "拒绝了写您的终端"

#: term-utils/mesg.c:161
#, c-format
msgid "invalid argument: %s"
msgstr "无效参数：%s"

#: term-utils/script.c:161
#, c-format
msgid " %s [options] [file]\n"
msgstr " %s [选项] [文件]\n"

#: term-utils/script.c:164
msgid "Make a typescript of a terminal session.\n"
msgstr "创建终端会话的 typescript。\n"

#: term-utils/script.c:167
#, fuzzy
msgid ""
" -a, --append                  append the output\n"
" -c, --command <command>       run command rather than interactive shell\n"
" -e, --return                  return exit code of the child process\n"
" -f, --flush                   run flush after each write\n"
"     --force                   use output file even when it is a link\n"
" -q, --quiet                   be quiet\n"
" -t[<file>], --timing[=<file>] output timing data to stderr or to FILE\n"
msgstr ""
" -a, --append            追加输出\n"
" -c, --command <命令>    运行命令而不是交互式 shell\n"
" -e, --return            返回子进程的退出代码\n"
" -f, --flush             每次 write(写) 后运行 flush(冲刷)\n"
"     --force             即使输出文件是链接也依然使用\n"
" -q, --quiet             安静模式\n"
" -t, --timing[=<文件>]   将时间数据输出到标准错误(或文件)\n"
" -V, --version           输出版本信息并退出\n"
" -h, --help              显示此帮助并退出\n"
"\n"

#: term-utils/script.c:189
#, c-format
msgid ""
"output file `%s' is a link\n"
"Use --force if you really want to use it.\n"
"Program not started."
msgstr ""
"输出文件“%s”是链接\n"
"如果真想用它，使用 --force 选项。\n"
"程序没有启动。"

#: term-utils/script.c:225
#, c-format
msgid "Script done, file is %s\n"
msgstr "脚本完成，文件为  %s\n"

#: term-utils/script.c:288
msgid "cannot write script file"
msgstr "无法写脚本文件"

#: term-utils/script.c:429
#, c-format
msgid ""
"\n"
"Session terminated.\n"
msgstr ""
"\n"
"会话已终止。\n"

#: term-utils/script.c:476
#, fuzzy, c-format
msgid "Script started on %s\n"
msgstr "脚本已于 %s 启动"

#: term-utils/script.c:548
#, fuzzy, c-format
msgid ""
"\n"
"Script done on %s\n"
msgstr ""
"\n"
"脚本完成，于 %s"

#: term-utils/script.c:639
msgid "openpty failed"
msgstr "openpty 失败"

#: term-utils/script.c:677
msgid "out of pty's"
msgstr "pty 的输出"

#: term-utils/script.c:777
#, c-format
msgid "Script started, file is %s\n"
msgstr "脚本已启动，文件为 %s\n"

#: term-utils/scriptreplay.c:44
#, c-format
msgid " %s [-t] timingfile [typescript] [divisor]\n"
msgstr " %s [-t] timingfile [typescript] [divisor]\n"

#: term-utils/scriptreplay.c:48
msgid "Play back terminal typescripts, using timing information.\n"
msgstr "使用定时信息回话终端 typescript。\n"

#: term-utils/scriptreplay.c:51
#, fuzzy
msgid ""
" -t, --timing <file>     script timing output file\n"
" -s, --typescript <file> script terminal session output file\n"
" -d, --divisor <num>     speed up or slow down execution with time divisor\n"
" -m, --maxdelay <num>    wait at most this many seconds between updates\n"
msgstr ""
" -t, --timing <文件>     脚本时序输出文件\n"
" -s, --typescript <文件> 脚本终端会话输出文件\n"
" -d, --divisor <数字>    用时间除数加速或减速执行\n"
" -m, --maxdelay <数字>   在更新之间最多等待这么多秒\n"
" -V, --version           输出版本信息并退出\n"
" -h, --help              显示此帮助并退出\n"
"\n"

#: term-utils/scriptreplay.c:113
msgid "write to stdout failed"
msgstr "写 stdout 失败"

#: term-utils/scriptreplay.c:119
#, c-format
msgid "unexpected end of file on %s"
msgstr "%s 上的文件结尾异常"

#: term-utils/scriptreplay.c:121
#, c-format
msgid "failed to read typescript file %s"
msgstr "读 typescript 文件 %s 失败"

#: term-utils/scriptreplay.c:185
msgid "wrong number of arguments"
msgstr "参数个数不正确"

#: term-utils/scriptreplay.c:216
#, c-format
msgid "failed to read timing file %s"
msgstr "读时序文件 %s 失败"

#: term-utils/scriptreplay.c:218
#, c-format
msgid "timing file %s: line %lu: unexpected format"
msgstr "定时文件 %s：第 %lu 行：格式异常。"

#: term-utils/setterm.c:237
#, c-format
msgid "argument error: bright %s is not supported"
msgstr "参数错误：不支持亮度 %s"

#: term-utils/setterm.c:326
msgid "too many tabs"
msgstr "标签过多"

#: term-utils/setterm.c:382
msgid "Set the attributes of a terminal.\n"
msgstr "设置终端属性。\n"

#: term-utils/setterm.c:385
msgid " --term          <terminal_name>   override TERM environment variable\n"
msgstr " --term          <终端名>          替换 TERM 环境变量\n"

#: term-utils/setterm.c:386
msgid " --reset                           reset terminal to power-on state\n"
msgstr " --reset                           重置端口到上电时的状态\n"

#: term-utils/setterm.c:387
#, fuzzy
msgid " --resize                          reset terminal rows and columns\n"
msgstr " --reset                           重置端口到上电时的状态\n"

#: term-utils/setterm.c:388
msgid " --initialize                      display init string, and use default settings\n"
msgstr " --initialize                      显示初始化字符串，并使用默认设置\n"

#: term-utils/setterm.c:389
msgid " --default                         use default terminal settings\n"
msgstr " --default                         使用默认终端设置\n"

#: term-utils/setterm.c:390
msgid " --store                           save current terminal settings as default\n"
msgstr " --store                           将当前终端设置保存为默认值\n"

#: term-utils/setterm.c:391
msgid " --cursor        [on|off]          display cursor\n"
msgstr " --cursor        [on|off]          显示光标\n"

#: term-utils/setterm.c:392
msgid " --repeat        [on|off]          keyboard repeat\n"
msgstr " --repeat        [on|off]          键盘重复\n"

#: term-utils/setterm.c:393
msgid " --appcursorkeys [on|off]          cursor key application mode\n"
msgstr " --appcursorkeys [on|off]          光标键应用程序模式\n"

#: term-utils/setterm.c:394
msgid " --linewrap      [on|off]          continue on a new line when a line is full\n"
msgstr " --linewrap      [on|off]          一行满时在新行中继续\n"

#: term-utils/setterm.c:395
msgid " --inversescreen [on|off]          swap colors for the whole screen\n"
msgstr " --inversescreen [on|off]          交换整个屏幕的颜色\n"

#: term-utils/setterm.c:396
msgid " --foreground    default|<color>   set foreground color\n"
msgstr " --foreground    default|<颜色>    设置前景色\n"

#: term-utils/setterm.c:397
msgid " --background    default|<color>   set background color\n"
msgstr " --background    default|<颜色>    设置背景色\n"

#: term-utils/setterm.c:398
msgid " --ulcolor       [bright] <color>  set underlined text color\n"
msgstr " --ulcolor       [bright] <颜色>   设置下划线颜色\n"

#: term-utils/setterm.c:399
msgid " --hbcolor       [bright] <color>  set bold text color\n"
msgstr " --hbcolor       [bright] <颜色>   设置粗体字颜色\n"

#: term-utils/setterm.c:400
msgid "                 <color>: black blue cyan green grey magenta red white yellow\n"
msgstr "                 <颜色>：black blue cyan green grey magenta red white yellow\n"

#: term-utils/setterm.c:401
msgid " --bold          [on|off]          bold\n"
msgstr " --bold          [on|off]          粗体\n"

#: term-utils/setterm.c:402
msgid " --half-bright   [on|off]          dim\n"
msgstr " -half-bright    [on|off]          变暗\n"

#: term-utils/setterm.c:403
msgid " --blink         [on|off]          blink\n"
msgstr " --blink         [on|off]          闪烁\n"

#: term-utils/setterm.c:404
msgid " --underline     [on|off]          underline\n"
msgstr " --underline     [on|off]          下划线\n"

#: term-utils/setterm.c:405
msgid " --reverse       [on|off]          swap foreground and background colors\n"
msgstr " --reverse       [on|off]          交换前景色和背景色\n"

#: term-utils/setterm.c:406
msgid " --clear         [all|rest]        clear screen and set cursor position\n"
msgstr " --clear         [all|rest]        清屏并设置光标位置\n"

#: term-utils/setterm.c:407
msgid " --tabs          [<number>...]     set these tab stop positions, or show them\n"
msgstr " --tabs          [<数字>...]       设置这些制表位置，或显示制表位\n"

#: term-utils/setterm.c:408
msgid " --clrtabs       [<number>...]     clear these tab stop positions, or all\n"
msgstr " --clrtabs       [<数字>...]       清除这些或所有制表位\n"

#: term-utils/setterm.c:409
msgid " --regtabs       [1-160]           set a regular tab stop interval\n"
msgstr " --regtabs       [1-160]           设置常规的制表位间隔\n"

#: term-utils/setterm.c:410
msgid " --blank         [0-60|force|poke] set time of inactivity before screen blanks\n"
msgstr " --blank         [0-60|force|poke] 设置多久不活动后屏幕变空白\n"

#: term-utils/setterm.c:411
msgid " --dump          [<number>]        write vcsa<number> console dump to file\n"
msgstr " --dump          [<数字>]          将 vcsa<数字> 终端转储到文件\n"

#: term-utils/setterm.c:412
msgid " --append        [<number>]        append vcsa<number> console dump to file\n"
msgstr " --append        [<数字>]          将 vcsa<数字> 终端转储追加到文件\n"

#: term-utils/setterm.c:413
msgid " --file          <filename>        name of the dump file\n"
msgstr " -f, --file      <文件名>          转储文件的名字\n"

#: term-utils/setterm.c:414
msgid " --msg           [on|off]          send kernel messages to console\n"
msgstr " --msg           [on|off]          将内核消息发送到终端\n"

#: term-utils/setterm.c:415
msgid " --msglevel      0-8               kernel console log level\n"
msgstr " --msglevel      0-8               内核终端日志记录级别\n"

#: term-utils/setterm.c:416
msgid " --powersave     [on|vsync|hsync|powerdown|off]\n"
msgstr " -powersave      [on|vsync|hsync|powerdown|off]\n"

#: term-utils/setterm.c:417
msgid "                                   set vesa powersaving features\n"
msgstr "                                   设置 vesa 节能功能\n"

#: term-utils/setterm.c:418
msgid " --powerdown     [0-60]            set vesa powerdown interval in minutes\n"
msgstr " --powerdown     [0-60]            设置 vesa 关闭电源间隔(分钟)\n"

#: term-utils/setterm.c:419
msgid " --blength       [0-2000]          duration of the bell in milliseconds\n"
msgstr " --blength       [0-2000]          响铃持续时间(毫秒)\n"

#: term-utils/setterm.c:420
msgid " --bfreq         <number>          bell frequency in Hertz\n"
msgstr " --bfreq         <数字>            响铃频率，单位为 Hz\n"

#: term-utils/setterm.c:431
msgid "duplicate use of an option"
msgstr "重复使用某选项"

#: term-utils/setterm.c:740
msgid "cannot force blank"
msgstr "无法强制清空(blank)"

#: term-utils/setterm.c:745
msgid "cannot force unblank"
msgstr "无法强制反清空(unblank)"

#: term-utils/setterm.c:751
msgid "cannot get blank status"
msgstr "无法获取空白状态"

#: term-utils/setterm.c:777
#, fuzzy, c-format
msgid "cannot open dump file %s for output"
msgstr "无法打开转储文件 %s 进行输出"

#: term-utils/setterm.c:819
#, c-format
msgid "terminal %s does not support %s"
msgstr "终端 %s 不支持 %s"

#: term-utils/setterm.c:857
#, fuzzy
msgid "select failed"
msgstr "定位失败"

#: term-utils/setterm.c:883
msgid "stdin does not refer to a terminal"
msgstr ""

#: term-utils/setterm.c:911
#, fuzzy, c-format
msgid "invalid cursor position: %s"
msgstr "无效选项"

#: term-utils/setterm.c:933
#, fuzzy
msgid "reset failed"
msgstr "setgid 失败"

#: term-utils/setterm.c:1097
msgid "cannot (un)set powersave mode"
msgstr "无法设置(取消)节能模式"

#: term-utils/setterm.c:1116 term-utils/setterm.c:1125
msgid "klogctl error"
msgstr "klogctl 出错"

#: term-utils/setterm.c:1146
msgid "$TERM is not defined."
msgstr "$TERM 未定义。"

#: term-utils/setterm.c:1153
msgid "terminfo database cannot be found"
msgstr "找不到 terminfo 数据库"

#: term-utils/setterm.c:1155
#, c-format
msgid "%s: unknown terminal type"
msgstr "%s：未知终端类型"

#: term-utils/setterm.c:1157
msgid "terminal is hardcopy"
msgstr "终端为硬拷贝(hardcopy)"

#: term-utils/ttymsg.c:81
#, c-format
msgid "internal error: too many iov's"
msgstr "内部错误：iov 过多"

#: term-utils/ttymsg.c:94
#, c-format
msgid "excessively long line arg"
msgstr "参数行超长"

#: term-utils/ttymsg.c:108
#, c-format
msgid "open failed"
msgstr "打开失败"

#: term-utils/ttymsg.c:147
#, c-format
msgid "fork: %m"
msgstr "fork：%m"

#: term-utils/ttymsg.c:149
#, c-format
msgid "cannot fork"
msgstr "无法 fork"

#: term-utils/ttymsg.c:182
#, c-format
msgid "%s: BAD ERROR, message is far too long"
msgstr "%s：严重错误，消息太长太长了"

#: term-utils/wall.c:86
#, c-format
msgid " %s [options] [<file> | <message>]\n"
msgstr " %s [选项] [<文件> | <消息>]\n"

#: term-utils/wall.c:89
msgid "Write a message to all users.\n"
msgstr "向所有用户发消息。\n"

#: term-utils/wall.c:92
#, fuzzy
msgid " -g, --group <group>     only send message to group\n"
msgstr " -g, --group <组>                指定主组\n"

#: term-utils/wall.c:93
msgid " -n, --nobanner          do not print banner, works only for root\n"
msgstr " -n, --nobanner          不打印欢迎消息，只对 root 用户生效\n"

#: term-utils/wall.c:94
msgid " -t, --timeout <timeout> write timeout in seconds\n"
msgstr " -t, --timeout <超时>    写超时(秒)\n"

#: term-utils/wall.c:122
#, fuzzy
msgid "invalid group argument"
msgstr "无效的周期参数"

#: term-utils/wall.c:124
#, fuzzy, c-format
msgid "%s: unknown gid"
msgstr "%c：未知命令"

#: term-utils/wall.c:167
msgid "getgrouplist found more groups than sysconf allows"
msgstr ""

#: term-utils/wall.c:213
msgid "--nobanner is available only for root"
msgstr "--nobanner 只有 root 能用"

#: term-utils/wall.c:218
#, c-format
msgid "invalid timeout argument: %s"
msgstr "无效的超时参数：%s"

#: term-utils/wall.c:357
msgid "cannot get passwd uid"
msgstr "无法获取 passwd uid"

#: term-utils/wall.c:362
msgid "cannot get tty name"
msgstr "无法获得 tty 名称"

#: term-utils/wall.c:382
#, c-format
msgid "Broadcast message from %s@%s (%s) (%s):"
msgstr "来自 %s@%s (%s) (%s) 的广播消息："

#: term-utils/wall.c:415
#, c-format
msgid "will not read %s - use stdin."
msgstr "将不读 %s - 使用 stdin。"

#: term-utils/write.c:87
#, c-format
msgid " %s [options] <user> [<ttyname>]\n"
msgstr " %s [选项] <用户> [<tty名称>]\n"

#: term-utils/write.c:91
msgid "Send a message to another user.\n"
msgstr "向另一个用户发送消息。\n"

#: term-utils/write.c:116
#, c-format
msgid "effective gid does not match group of %s"
msgstr "有效 gid 与组 %s 不匹配"

#: term-utils/write.c:201
#, c-format
msgid "%s is not logged in"
msgstr "%s 未登录"

#: term-utils/write.c:206
msgid "can't find your tty's name"
msgstr "找不到您的 tty 名称"

#: term-utils/write.c:211
#, c-format
msgid "%s has messages disabled"
msgstr "%s 禁用了消息"

#: term-utils/write.c:214
#, c-format
msgid "%s is logged in more than once; writing to %s"
msgstr "%s 登录了多次；将记入 %s"

#: term-utils/write.c:237
msgid "carefulputc failed"
msgstr "carefulputc 失败"

#: term-utils/write.c:279
#, c-format
msgid "Message from %s@%s (as %s) on %s at %02d:%02d ..."
msgstr "%s@%s (作为 %s) 于 %s 在 %02d:%02d 发的消息..."

#: term-utils/write.c:283
#, c-format
msgid "Message from %s@%s on %s at %02d:%02d ..."
msgstr "%s@%s 于 %s 在 %02d:%02d 发的消息..."

#: term-utils/write.c:330
msgid "you have write permission turned off"
msgstr "您关闭了写权限"

#: term-utils/write.c:353
#, c-format
msgid "%s is not logged in on %s"
msgstr "%s 未在 %s 上登录"

#: term-utils/write.c:359
#, c-format
msgid "%s has messages disabled on %s"
msgstr "%s 在 %s 上禁用了消息"

#: text-utils/col.c:135
msgid "Filter out reverse line feeds.\n"
msgstr "过滤反换行。\n"

#: text-utils/col.c:138
#, fuzzy, c-format
msgid ""
"\n"
"Options:\n"
" -b, --no-backspaces    do not output backspaces\n"
" -f, --fine             permit forward half line feeds\n"
" -p, --pass             pass unknown control sequences\n"
" -h, --tabs             convert spaces to tabs\n"
" -x, --spaces           convert tabs to spaces\n"
" -l, --lines NUM        buffer at least NUM lines\n"
msgstr ""
"\n"
"选项：\n"
" -b, --no-backspaces    不输出退格键(backspace)\n"
" -f, --fine             允许前进半行(forward half line feed)\n"
" -p, --pass             传递未知的控制序列\n"
" -h, --tabs             将空格转换为制表符\n"
" -x, --spaces           将制表符转换为空格\n"
" -l, --lines NUM        缓冲至少 NUM 行\n"
" -V, --version          输出版本信息并退出\n"
" -H, --help             显示此帮助并退出\n"
"\n"

#: text-utils/col.c:151 text-utils/colrm.c:69
#, c-format
msgid ""
"%s reads from standard input and writes to standard output\n"
"\n"
msgstr ""
"%s 读取标准输入并写入标准输出\n"
"\n"

#: text-utils/col.c:215
msgid "bad -l argument"
msgstr "-l 参数有误"

#: text-utils/col.c:344
#, c-format
msgid "warning: can't back up %s."
msgstr "警告：无法备份 %s。"

#: text-utils/col.c:345
msgid "past first line"
msgstr "越过第一行"

#: text-utils/col.c:345
msgid "-- line already flushed"
msgstr "-- 行已经被冲洗(flushed)"

#: text-utils/colcrt.c:82 text-utils/column.c:634
#, c-format
msgid " %s [options] [<file>...]\n"
msgstr " %s [选项] [<文件>...]\n"

#: text-utils/colcrt.c:85
msgid "Filter nroff output for CRT previewing.\n"
msgstr "过滤 nroff 输出以便 CRT 预览。\n"

#: text-utils/colcrt.c:88
msgid " -,  --no-underlining    suppress all underlining\n"
msgstr " -,  --no-underlining    禁止所有下划线\n"

#: text-utils/colcrt.c:89
msgid " -2, --half-lines        print all half-lines\n"
msgstr " -2, --half-lines        打印所有半行\n"

#: text-utils/colrm.c:60
#, c-format
msgid ""
"\n"
"Usage:\n"
" %s [startcol [endcol]]\n"
msgstr ""
"\n"
"用法：\n"
" %s [起始列 [终止列]]\n"

#: text-utils/colrm.c:65
msgid "Filter out the specified columns.\n"
msgstr "过滤指定列。\n"

#: text-utils/colrm.c:185
msgid "first argument"
msgstr "第一个参数"

#: text-utils/colrm.c:187
msgid "second argument"
msgstr "第二个参数"

#: text-utils/column.c:235
#, fuzzy
msgid "failed to parse column"
msgstr "解析 终点 失败"

#: text-utils/column.c:245
#, fuzzy, c-format
msgid "undefined column name '%s'"
msgstr "未定义的挂载点"

#: text-utils/column.c:321
#, fuzzy
msgid "failed to parse --table-order list"
msgstr "解析 --timeout 失败"

#: text-utils/column.c:397
#, fuzzy
msgid "failed to parse --table-right list"
msgstr "解析 起点 失败"

#: text-utils/column.c:401
#, fuzzy
msgid "failed to parse --table-trunc list"
msgstr "解析 --timeout 失败"

#: text-utils/column.c:405
#, fuzzy
msgid "failed to parse --table-noextreme list"
msgstr "解析 --timeout 失败"

#: text-utils/column.c:409
#, fuzzy
msgid "failed to parse --table-wrap list"
msgstr "解析 起点 失败"

#: text-utils/column.c:413
#, fuzzy
msgid "failed to parse --table-hide list"
msgstr "解析 --timeout 失败"

#: text-utils/column.c:444
#, c-format
msgid "line %zu: for JSON the name of the column %zu is required"
msgstr ""

#: text-utils/column.c:458
#, fuzzy
msgid "failed to allocate output data"
msgstr "分配输出表失败"

#: text-utils/column.c:637
msgid "Columnate lists.\n"
msgstr "成列输出内容。\n"

#: text-utils/column.c:640
#, fuzzy
msgid " -t, --table                      create a table\n"
msgstr " -t, --table              创建表格\n"

#: text-utils/column.c:641
#, fuzzy
msgid " -n, --table-name <name>          table name for JSON output\n"
msgstr " -n, --name <progname>         要报告其错误的程序名称\n"

#: text-utils/column.c:642
#, fuzzy
msgid " -O, --table-order <columns>      specify order of output columns\n"
msgstr " -x, --sort <列>      按<列>对输出排序\n"

#: text-utils/column.c:643
#, fuzzy
msgid " -N, --table-columns <names>      comma separated columns names\n"
msgstr " -o, --options <列表>     以英文逗号分隔的 swap 选项\n"

#: text-utils/column.c:644
msgid " -E, --table-noextreme <columns>  don't count long text from the columns to column width\n"
msgstr ""

#: text-utils/column.c:645
#, fuzzy
msgid " -d, --table-noheadings           don't print header\n"
msgstr " -n, --noheadings          不打印标题\n"

#: text-utils/column.c:646
msgid " -e, --table-header-repeat        repeat header for each page\n"
msgstr ""

#: text-utils/column.c:647
#, fuzzy
msgid " -H, --table-hide <columns>       don't print the columns\n"
msgstr " -n, --noheadings       不打印列标题\n"

#: text-utils/column.c:648
msgid " -R, --table-right <columns>      right align text in these columns\n"
msgstr ""

#: text-utils/column.c:649
#, fuzzy
msgid " -T, --table-truncate <columns>   truncate text in the columns when necessary\n"
msgstr " -u, --notruncate       不截断列中的文本\n"

#: text-utils/column.c:650
msgid " -W, --table-wrap <columns>       wrap text in the columns when necessary\n"
msgstr ""

#: text-utils/column.c:651
#, fuzzy
msgid " -J, --json                       use JSON output format for table\n"
msgstr " -J, --json                    使用 JSON --list 输出格式\n"

#: text-utils/column.c:654
#, fuzzy
msgid " -r, --tree <column>              column to use tree-like output for the table\n"
msgstr " -O, --output <列>           指定 --list 选项要输出的列\n"

#: text-utils/column.c:655
#, fuzzy
msgid " -i, --tree-id <column>           line ID to specify child-parent relation\n"
msgstr " -i, --irq <数字>             指定并口中断号\n"

#: text-utils/column.c:656
#, fuzzy
msgid " -p, --tree-parent <column>       parent to specify child-parent relation\n"
msgstr " -N, --partno <数字>       指定分区号\n"

#: text-utils/column.c:659
#, fuzzy
msgid " -c, --output-width <width>       width of output in number of characters\n"
msgstr " -c, --columns <宽度>     输出宽度(字符数)\n"

#: text-utils/column.c:660
#, fuzzy
msgid " -o, --output-separator <string>  columns separator for table output (default is two spaces)\n"
msgstr ""
" -o, --output-separator <字符串>\n"
"                          表格输出列分隔符，默认为两个空格\n"

#: text-utils/column.c:661
#, fuzzy
msgid " -s, --separator <string>         possible table delimiters\n"
msgstr " -s, --separator <字符串> 可用的表格分隔符\n"

#: text-utils/column.c:662
#, fuzzy
msgid " -x, --fillrows                   fill rows before columns\n"
msgstr " -x, --fillrows           先填充行，再填充列\n"

#: text-utils/column.c:731
msgid "invalid columns argument"
msgstr "无效的 列数 参数"

#: text-utils/column.c:756
#, fuzzy
msgid "failed to parse column names"
msgstr "解析挂臷表失败"

#: text-utils/column.c:811
msgid "options --tree-id and --tree-parent are required for tree formatting"
msgstr ""

#: text-utils/column.c:819
msgid "option --table required for all --table-*"
msgstr ""

#: text-utils/column.c:822
msgid "option --table-columns required for --json"
msgstr ""

#: text-utils/hexdump.c:156 text-utils/more.c:232
#, c-format
msgid " %s [options] <file>...\n"
msgstr " %s [选项] <文件>...\n"

#: text-utils/hexdump.c:159
msgid "Display file contents in hexadecimal, decimal, octal, or ascii.\n"
msgstr "以十六进制、十进制、八进制、二进制或 ascii 显示文件内容。\n"

#: text-utils/hexdump.c:162
msgid " -b, --one-byte-octal      one-byte octal display\n"
msgstr " -b, --one-byte-octal      单字节八进制显示\n"

#: text-utils/hexdump.c:163
msgid " -c, --one-byte-char       one-byte character display\n"
msgstr " -c, --one-byte-char       单字节字符显示\n"

#: text-utils/hexdump.c:164
msgid " -C, --canonical           canonical hex+ASCII display\n"
msgstr " -C, --canonical           规范化 hex+ASCII 显示\n"

#: text-utils/hexdump.c:165
msgid " -d, --two-bytes-decimal   two-byte decimal display\n"
msgstr " -d, --two-bytes-decimal   双字节十进制显示\n"

#: text-utils/hexdump.c:166
msgid " -o, --two-bytes-octal     two-byte octal display\n"
msgstr " -o, --two-bytes-octal     双字节八进制显示\n"

#: text-utils/hexdump.c:167
msgid " -x, --two-bytes-hex       two-byte hexadecimal display\n"
msgstr " -x, --two-bytes-hex       双字节十六进制显示\n"

#: text-utils/hexdump.c:168
msgid " -L, --color[=<mode>]      interpret color formatting specifiers\n"
msgstr " -L, --color[=<模式>]      解释颜色格式化限定符\n"

#: text-utils/hexdump.c:171
msgid " -e, --format <format>     format string to be used for displaying data\n"
msgstr " -e, --format <格式>       用于显示数据的格式化字符串\n"

#: text-utils/hexdump.c:172
msgid " -f, --format-file <file>  file that contains format strings\n"
msgstr " -f, --format-file <文件>  包含格式字符串的文件\n"

#: text-utils/hexdump.c:173
msgid " -n, --length <length>     interpret only length bytes of input\n"
msgstr " -n, --length <长度>       只解释规定字节长度的输入\n"

#: text-utils/hexdump.c:174
msgid " -s, --skip <offset>       skip offset bytes from the beginning\n"
msgstr " -s, --skip <偏移>         跳过开头的指定字节偏移\n"

#: text-utils/hexdump.c:175
msgid " -v, --no-squeezing        output identical lines\n"
msgstr " -v, --no-squeezing        输出相同的行\n"

#: text-utils/hexdump-display.c:365
msgid "all input file arguments failed"
msgstr "所有输入文件参数失败"

#: text-utils/hexdump-parse.c:55
#, c-format
msgid "bad byte count for conversion character %s"
msgstr "转换字符 %s 的转换字符计数错误"

#: text-utils/hexdump-parse.c:60
#, c-format
msgid "%%s requires a precision or a byte count"
msgstr "%%s 需要指定精度或字符计数"

#: text-utils/hexdump-parse.c:65
#, c-format
msgid "bad format {%s}"
msgstr "格式损坏 {%s}"

#: text-utils/hexdump-parse.c:70
#, c-format
msgid "bad conversion character %%%s"
msgstr "转换字符 %%%s 有误"

#: text-utils/hexdump-parse.c:436
msgid "byte count with multiple conversion characters"
msgstr "对字符计数使用了多个转换字符"

#: text-utils/line.c:34
msgid "Read one line.\n"
msgstr "读一行内容。\n"

#: text-utils/more.c:235
msgid "A file perusal filter for CRT viewing.\n"
msgstr "适合屏幕查看的文件阅读输出工具。\n"

#: text-utils/more.c:238
msgid " -d          display help instead of ringing bell\n"
msgstr " -d          显示帮助而非响铃\n"

#: text-utils/more.c:239
msgid " -f          count logical rather than screen lines\n"
msgstr " -f          计算逻辑行数，而非屏幕行数\n"

#: text-utils/more.c:240
msgid " -l          suppress pause after form feed\n"
msgstr " -l          屏蔽换页(form feed)后的暂停\n"

#: text-utils/more.c:241
msgid " -c          do not scroll, display text and clean line ends\n"
msgstr " -c          不滚动，显示文本并清理行末\n"

#: text-utils/more.c:242
msgid " -p          do not scroll, clean screen and display text\n"
msgstr " -p          不滚动，清除屏幕并显示文本\n"

#: text-utils/more.c:243
msgid " -s          squeeze multiple blank lines into one\n"
msgstr " -s          将多行空行压缩为一行\n"

#: text-utils/more.c:244
msgid " -u          suppress underlining\n"
msgstr " -u          屏蔽下划线\n"

#: text-utils/more.c:245
msgid " -<number>   the number of lines per screenful\n"
msgstr " -<数字>     每屏的行数\n"

#: text-utils/more.c:246
msgid " +<number>   display file beginning from line number\n"
msgstr " +<数字>     从指定行开始显示文件\n"

#: text-utils/more.c:247
msgid " +/<string>  display file beginning from search string match\n"
msgstr " +/<字符串>  从匹配搜索字符串的位置开始显示文件\n"

#: text-utils/more.c:505
#, c-format
msgid "unknown option -%s"
msgstr "未知选项 -%s"

#: text-utils/more.c:529
#, c-format
msgid ""
"\n"
"*** %s: directory ***\n"
"\n"
msgstr ""
"\n"
"*** %s：目录 ***\n"
"\n"

#: text-utils/more.c:571
#, c-format
msgid ""
"\n"
"******** %s: Not a text file ********\n"
"\n"
msgstr ""
"\n"
"******** %s：不是文件文件 ********\n"
"\n"

#: text-utils/more.c:666
#, c-format
msgid "[Use q or Q to quit]"
msgstr "[使用 q 或 Q 退出]"

#: text-utils/more.c:745
#, c-format
msgid "--More--"
msgstr "--更多--"

#: text-utils/more.c:747
#, c-format
msgid "(Next file: %s)"
msgstr "(下个文件：%s)"

#: text-utils/more.c:755
#, c-format
msgid "[Press space to continue, 'q' to quit.]"
msgstr "[按空格键继续，“q”键退出。]"

#: text-utils/more.c:1183
#, c-format
msgid "...back %d page"
msgid_plural "...back %d pages"
msgstr[0] "...后退 %d 页"

#: text-utils/more.c:1231
#, c-format
msgid "...skipping %d line"
msgid_plural "...skipping %d lines"
msgstr[0] "...跳过 %d 行"

#: text-utils/more.c:1269
msgid ""
"\n"
"***Back***\n"
"\n"
msgstr ""
"\n"
"***后退***\n"
"\n"

#: text-utils/more.c:1284
msgid "No previous regular expression"
msgstr "无上一个正则表达式"

#: text-utils/more.c:1314
msgid ""
"\n"
"Most commands optionally preceded by integer argument k.  Defaults in brackets.\n"
"Star (*) indicates argument becomes new default.\n"
msgstr ""
"\n"
"多数命令可在前面加整数参数 k。方括号中为参数的默认值\n"
"星号(*)表示参数将成为新的默认值。\n"

#: text-utils/more.c:1321
msgid ""
"<space>                 Display next k lines of text [current screen size]\n"
"z                       Display next k lines of text [current screen size]*\n"
"<return>                Display next k lines of text [1]*\n"
"d or ctrl-D             Scroll k lines [current scroll size, initially 11]*\n"
"q or Q or <interrupt>   Exit from more\n"
"s                       Skip forward k lines of text [1]\n"
"f                       Skip forward k screenfuls of text [1]\n"
"b or ctrl-B             Skip backwards k screenfuls of text [1]\n"
"'                       Go to place where previous search started\n"
"=                       Display current line number\n"
"/<regular expression>   Search for kth occurrence of regular expression [1]\n"
"n                       Search for kth occurrence of last r.e [1]\n"
"!<cmd> or :!<cmd>       Execute <cmd> in a subshell\n"
"v                       Start up /usr/bin/vi at current line\n"
"ctrl-L                  Redraw screen\n"
":n                      Go to kth next file [1]\n"
":p                      Go to kth previous file [1]\n"
":f                      Display current file name and line number\n"
".                       Repeat previous command\n"
msgstr ""
"<空格键>                显示下 k 行文本[当前屏幕尺寸]\n"
"z                       显示下 k 行文本[当前屏幕尺寸]*\n"
"<回车键>                显示下 k 行文本[1]*\n"
"d 或 ctrl-D             滚动 k 行[当前滚动尺寸，初始值为 11]*\n"
"q 或 Q 或 <interrupt>   退出 more\n"
"s                       跳过下面 k 行文本[1]\n"
"f                       跳过下面 k 屏文本[1]\n"
"b 或 ctrl-B             跳过上面 k 屏文本 [1]\n"
"'                       转到上次搜索开始处\n"
"=                       显示当前行号\n"
"/<正则表达式>           搜索正则表达式第 k 次出现处[1]\n"
"n                       搜索前一正则表达式第 k 次出现处[1]\n"
"!<cmd> 或 :!<cmd>       在子 shell 中执行 <cmd> 命令\n"
"v                       在当前行启动 /usr/bin/vi\n"
"ctrl-L                  重绘屏幕\n"
":n                      转到后面第 k 个文件[1]\n"
":p                      转到前面第 k 个文件 [1]\n"
":f                      显示当前文件名和行号\n"
".                       重复前一命令\n"

#: text-utils/more.c:1394 text-utils/more.c:1400
#, c-format
msgid "[Press 'h' for instructions.]"
msgstr "[按“h”键获取说明。]"

#: text-utils/more.c:1431
#, c-format
msgid "\"%s\" line %d"
msgstr "“%s”第 %d 行"

#: text-utils/more.c:1433
#, c-format
msgid "[Not a file] line %d"
msgstr "[不是文件] 第 %d 行"

#: text-utils/more.c:1515
msgid "  Overflow\n"
msgstr "  上溢\n"

#: text-utils/more.c:1564
msgid "...skipping\n"
msgstr "...跳过\n"

#: text-utils/more.c:1598
msgid ""
"\n"
"Pattern not found\n"
msgstr ""
"\n"
"未找到模式\n"

#: text-utils/more.c:1604 text-utils/pg.c:1035 text-utils/pg.c:1181
msgid "Pattern not found"
msgstr "找不到模式"

#: text-utils/more.c:1652
msgid "exec failed\n"
msgstr "exec 失败\n"

#: text-utils/more.c:1666
msgid "can't fork\n"
msgstr "无法 fork\n"

#: text-utils/more.c:1700
msgid ""
"\n"
"...Skipping "
msgstr ""
"\n"
"...跳过 "

#: text-utils/more.c:1704
msgid "...Skipping to file "
msgstr "...跳到文件 "

#: text-utils/more.c:1706
msgid "...Skipping back to file "
msgstr "...将跳回文件 "

#: text-utils/more.c:1995
msgid "Line too long"
msgstr "行过长"

#: text-utils/more.c:2032
msgid "No previous command to substitute for"
msgstr "没有要替换的前一命令"

#: text-utils/pg.c:152
msgid ""
"-------------------------------------------------------\n"
"  h                       this screen\n"
"  q or Q                  quit program\n"
"  <newline>               next page\n"
"  f                       skip a page forward\n"
"  d or ^D                 next halfpage\n"
"  l                       next line\n"
"  $                       last page\n"
"  /regex/                 search forward for regex\n"
"  ?regex? or ^regex^      search backward for regex\n"
"  . or ^L                 redraw screen\n"
"  w or z                  set page size and go to next page\n"
"  s filename              save current file to filename\n"
"  !command                shell escape\n"
"  p                       go to previous file\n"
"  n                       go to next file\n"
"\n"
"Many commands accept preceding numbers, for example:\n"
"+1<newline> (next page); -1<newline> (previous page); 1<newline> (first page).\n"
"\n"
"See pg(1) for more information.\n"
"-------------------------------------------------------\n"
msgstr ""
"-------------------------------------------------------\n"
"  h                       此屏幕\n"
"  q 或 Q                  退出程序\n"
"  <换行>                  下一页\n"
"  f                       跳过下一页\n"
"  d 或 ^D                 下半页\n"
"  l                       下一行\n"
"  $                       上一页\n"
"  /表达式/                往前搜索正则表达式\n"
"  ?表达式? 或 ^表达式^    往回搜索正则表达式\n"
"  . 或 ^L                 重绘屏幕\n"
"  w 或 z                  设置页尺寸并转到下一页\n"
"  s filename              以 filename 为名字保存当前文件\n"
"  !command                shell 转义\n"
"  p                       转到前一文件\n"
"  n                       转到下一文件\n"
"\n"
"很多命令前接受数字参数，如：\n"
"+1<换行> (下一页); -1<换行> (上一页); 1<换行> (第一页)。\n"
"\n"
"更多信息请参阅 pg(1)。\n"
"-------------------------------------------------------\n"

#: text-utils/pg.c:231
#, c-format
msgid " %s [options] [+line] [+/pattern/] [files]\n"
msgstr " %s [选项] [+行] [+/模式/] [文件]\n"

#: text-utils/pg.c:235
msgid "Browse pagewise through text files.\n"
msgstr "逐页查看文本文件。\n"

#: text-utils/pg.c:238
msgid " -number      lines per page\n"
msgstr " -number      每页的行数\n"

#: text-utils/pg.c:239
msgid " -c           clear screen before displaying\n"
msgstr " -c           显示前清屏\n"

#: text-utils/pg.c:240
msgid " -e           do not pause at end of a file\n"
msgstr " -e           不在文件末尾暂停\n"

#: text-utils/pg.c:241
msgid " -f           do not split long lines\n"
msgstr " -f           不分割长行\n"

#: text-utils/pg.c:242
msgid " -n           terminate command with new line\n"
msgstr " -n           用换行符(new line)终止命令\n"

#: text-utils/pg.c:243
msgid " -p <prompt>  specify prompt\n"
msgstr " -p <提示>    指定提示语\n"

#: text-utils/pg.c:244
msgid " -r           disallow shell escape\n"
msgstr " -r           禁止 shell 转义\n"

#: text-utils/pg.c:245
msgid " -s           print messages to stdout\n"
msgstr " -s           向标准输出打印消息\n"

#: text-utils/pg.c:246
msgid " +number      start at the given line\n"
msgstr " +数字        从指定行开始\n"

#: text-utils/pg.c:247
msgid " +/pattern/   start at the line containing pattern\n"
msgstr " +/模式/      从包含 模式 的行开始\n"

#: text-utils/pg.c:258
#, c-format
msgid "option requires an argument -- %s"
msgstr "选项需要一个参数 -- %s"

#: text-utils/pg.c:264
#, c-format
msgid "illegal option -- %s"
msgstr "非法的参数 -- %s"

#: text-utils/pg.c:367
msgid "...skipping forward\n"
msgstr "...前进\n"

#: text-utils/pg.c:369
msgid "...skipping backward\n"
msgstr "...后退\n"

#: text-utils/pg.c:385
msgid "No next file"
msgstr "无下一个文件"

#: text-utils/pg.c:389
msgid "No previous file"
msgstr "无上一个文件"

#: text-utils/pg.c:891
#, c-format
msgid "Read error from %s file"
msgstr "从 %s 文件读出错"

#: text-utils/pg.c:894
#, c-format
msgid "Unexpected EOF in %s file"
msgstr "在 %s 文件中遇到异常 EOF"

#: text-utils/pg.c:896
#, c-format
msgid "Unknown error in %s file"
msgstr "在 %s 文件中遇到未知错误"

#: text-utils/pg.c:949
msgid "Cannot create temporary file"
msgstr "无法创建临时文件"

#: text-utils/pg.c:958 text-utils/pg.c:1122 text-utils/pg.c:1148
msgid "RE error: "
msgstr "表达式错误："

#: text-utils/pg.c:1105
msgid "(EOF)"
msgstr "(文件末尾)"

#: text-utils/pg.c:1130 text-utils/pg.c:1156
msgid "No remembered search string"
msgstr "没有记忆的搜索字符串"

#: text-utils/pg.c:1211
msgid "cannot open "
msgstr "打不开 "

#: text-utils/pg.c:1263
msgid "saved"
msgstr "已保存"

#: text-utils/pg.c:1353
msgid ": !command not allowed in rflag mode.\n"
msgstr ": !命令 在 rflag 模式下不许使用。\n"

#: text-utils/pg.c:1387
msgid "fork() failed, try again later\n"
msgstr "fork() 失败，请稍后重试\n"

#: text-utils/pg.c:1475
msgid "(Next file: "
msgstr "(下个文件："

#: text-utils/pg.c:1541
#, c-format
msgid "%s %s Copyright (c) 2000-2001 Gunnar Ritter. All rights reserved.\n"
msgstr "%s %s Copyright (c) 2000-2001 Gunnar Ritter. All rights reserved.\n"

#: text-utils/pg.c:1594 text-utils/pg.c:1667
msgid "failed to parse number of lines per page"
msgstr "解析每页的行数失败"

#: text-utils/rev.c:77
#, c-format
msgid "Usage: %s [options] [file ...]\n"
msgstr "用法：%s [选项] [文件 ...]\n"

#: text-utils/rev.c:81
msgid "Reverse lines characterwise.\n"
msgstr "对成行的内容逐字翻转。\n"

#: text-utils/ul.c:142
#, c-format
msgid " %s [options] [<file> ...]\n"
msgstr " %s [选项] [<文件> ...]\n"

#: text-utils/ul.c:145
msgid "Do underlining.\n"
msgstr "加下划线。\n"

#: text-utils/ul.c:148
msgid " -t, -T, --terminal TERMINAL  override the TERM environment variable\n"
msgstr " -t, -T, --terminal TERMINAL  用 TERMINAL 覆盖 TERM 环境变量的值\n"

#: text-utils/ul.c:149
msgid " -i, --indicated              underlining is indicated via a separate line\n"
msgstr " -i, --indicated              通过单独一行表示下划线\n"

#: text-utils/ul.c:209
msgid "trouble reading terminfo"
msgstr "读取终端信息出错"

#: text-utils/ul.c:214
#, c-format
msgid "terminal `%s' is not known, defaulting to `dumb'"
msgstr "终端“%s”未知，将使用默认值“dumb”"

#: text-utils/ul.c:304
#, c-format
msgid "unknown escape sequence in input: %o, %o"
msgstr "输入中有未知转义序列：%o，%o"

#: text-utils/ul.c:629
msgid "Input line too long."
msgstr "输入行过长。"

#~ msgid "Geometry"
#~ msgstr "几何属性"

#~ msgid "kind of lock: FL_FLOCK or FL_POSIX."
#~ msgstr "锁类型：FL_FLOCK 或 FL_POSIX。"

#~ msgid "unable to exec /bin/umount of `%s'"
#~ msgstr "无法对“%s”执行 /bin/umount"

#~ msgid "sleeping ~%d usec\n"
#~ msgstr "将睡眠 ~%d 微秒\n"

#~ msgid "%ld.%06ld < %ld.%06ld (%.6f)\n"
#~ msgstr "%ld.%06ld < %ld.%06ld (%.6f)\n"

#, fuzzy
#~ msgid " -D, --debug          display more details"
#~ msgstr "     --verbose          打印更多细节\n"

#~ msgid "failed to read from: %s"
#~ msgstr "读取失败︰ %s"

#~ msgid "cannot execute: %s"
#~ msgstr "无法执行：%s"

#~ msgid "unsupported algorithm: %s"
#~ msgstr "不支持的算法︰%s"

#, fuzzy
#~ msgid ""
#~ "Test mode: %s was not updated with:\n"
#~ "%s"
#~ msgstr "设备 %s 未与 %s 关联\n"

#~ msgid "Could not open file with the clock adjustment parameters in it (%s) for writing"
#~ msgstr "无法打开包含时钟调整参数(%s)的文件来写入"

#~ msgid "Could not update file with the clock adjustment parameters (%s) in it"
#~ msgstr "无法更新包含时钟调整参数(%s)的文件"

#~ msgid "Drift adjustment parameters not updated."
#~ msgstr "漂移调整参数未更新。"

#, fuzzy
#~ msgid "Test mode: epoch was not set to %s.\n"
#~ msgstr "上次更改时间"

#~ msgid ""
#~ "\n"
#~ "Usage:\n"
#~ " %1$s -V\n"
#~ " %1$s --report [devices]\n"
#~ " %1$s [-v|-q] commands devices\n"
#~ "\n"
#~ "Available commands:\n"
#~ msgstr ""
#~ "\n"
#~ "用法：\n"
#~ " %1$s -V\n"
#~ " %1$s --report [设备]\n"
#~ " %1$s [-v|-q] 命令 设备\n"
#~ "\n"
#~ "可用命令有：\n"

#~ msgid ""
#~ "\n"
#~ "Available columns (for -o):\n"
#~ msgstr ""
#~ "\n"
#~ "可用列(用于 -o)：\n"

#~ msgid "seek error on %s"
#~ msgstr "%s 定位出错"

#~ msgid ""
#~ " -V, --version      display version information and exit;\n"
#~ "                      -V as --version must be the only option\n"
#~ msgstr ""
#~ " -V, --version      显示版本信息并退出\n"
#~ "                      将 -V 作为 --version 选项时必须是惟一选项\n"

#~ msgid " -h, --help         display this help text and exit\n"
#~ msgstr " -h, --help         显示此帮助并退出\n"

#~ msgid ""
#~ "\n"
#~ "Available columns (for --show, --raw or --pairs):\n"
#~ msgstr ""
#~ "\n"
#~ "可用的列(针对 --show、--raw 或 --pairs)：\n"

#~ msgid " -v, --version  output version information and exit\n"
#~ msgstr " -v, --version  输出版本信息并退出\n"

#, fuzzy
#~ msgid "Try '%s -h' for more information.\n"
#~ msgstr "请尝试执行“%s --help”了解更多信息。\n"

#~ msgid " -h, --help     display this help and exit\n"
#~ msgstr " -h, --help     显示此帮助并退出\n"

#~ msgid " -V, --version  output version information and exit\n"
#~ msgstr " -V, --version  输出版本信息并退出\n"

#~ msgid " -u, --help     display this help and exit\n"
#~ msgstr " -u, --help     显示此帮助并退出\n"

#~ msgid "No known shells."
#~ msgstr "无已知 shell。"

#~ msgid ""
#~ "\n"
#~ "Available columns:\n"
#~ msgstr ""
#~ "\n"
#~ "可用的列：\n"

#, fuzzy
#~ msgid " %s [options] -u <user> [[--] <command>]\n"
#~ msgstr " %s [选项] -u <用户> <命令>\n"

#~ msgid ""
#~ "\n"
#~ "Available columns (for --output):\n"
#~ msgstr ""
#~ "\n"
#~ "可用列(用于 --output)：\n"

#~ msgid "Try `%s --help' for more information.\n"
#~ msgstr "请尝试执行“%s --help”了解更多信息。\n"

#~ msgid " -v, --verbose    explain what is being done\n"
#~ msgstr " -v, --verbose    解释正在进行的操作\n"

#~ msgid ""
#~ " -r, --random     generate random-based uuid\n"
#~ " -t, --time       generate time-based uuid\n"
#~ " -V, --version    output version information and exit\n"
#~ " -h, --help       display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -r, --random     生成基于随机数的 uuid\n"
#~ " -t, --time       生成基于时间的 uuid\n"
#~ " -V, --version    输出版本信息并退出\n"
#~ " -h, --help       显示此帮助并退出\n"
#~ "\n"

#~ msgid ""
#~ " -a, --all           wipe all magic strings (BE CAREFUL!)\n"
#~ " -b, --backup        create a signature backup in $HOME\n"
#~ " -f, --force         force erasure\n"
#~ " -h, --help          show this help text\n"
#~ " -n, --no-act        do everything except the actual write() call\n"
#~ " -o, --offset <num>  offset to erase, in bytes\n"
#~ " -p, --parsable      print out in parsable instead of printable format\n"
#~ " -q, --quiet         suppress output messages\n"
#~ " -t, --types <list>  limit the set of filesystem, RAIDs or partition tables\n"
#~ " -V, --version       output version information and exit\n"
#~ msgstr ""
#~ " -a, --all           擦除所有魔数字符串(慎重！)\n"
#~ " -b, --backup        在 $HOME 中创建签名备份\n"
#~ " -f, --force         强制擦除\n"
#~ " -h, --help          显示此帮助文字\n"
#~ " -n, --no-act        照常操作但不执行实际的 write() 调用\n"
#~ " -o, --offset <数字> 要擦除的偏移字节数\n"
#~ " -p, --parsable      以可解析的格式打印输出，而非以可打印的格式\n"
#~ " -t, --types <列表>  限制文件系统、RAID 或分区表的集合\n"
#~ " -V, --version       输出版本信息并退出\n"

#~ msgid "The Hardware Clock registers contain values that are either invalid (e.g. 50th day of month) or beyond the range we can handle (e.g. Year 2095)."
#~ msgstr "硬件时钟寄存器包含的值无效(如一个月的第 50 天)或超出了程序能处理的范围(如2095年)。"

#~ msgid "The Hardware Clock does not contain a valid time, so we cannot set the System Time from it."
#~ msgstr "硬件时钟不包含有效时间，因此无法从它来设置系统时间。"

#~ msgid "\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"
#~ msgstr "\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"

#~ msgid "\ttz.tz_minuteswest = %d\n"
#~ msgstr "\ttz.tz_minuteswest = %d\n"

#~ msgid "Must be superuser to set system clock."
#~ msgstr "只能以超级用户身份来设置系统时钟。"

#~ msgid "\tUTC: %s\n"
#~ msgstr "\tUTC：%s\n"

#~ msgid "Not adjusting drift factor because the Hardware Clock previously contained garbage.\n"
#~ msgstr "将不调整漂移系数，因为之前硬件时钟包含垃圾内容。\n"

#~ msgid "The Hardware Clock does not contain a valid time, so we cannot adjust it."
#~ msgstr "硬件时间不包含有效时间，程序无法调整它。"

#~ msgid "At %ld seconds after 1969, RTC is predicted to read %ld seconds after 1969.\n"
#~ msgstr "位于1969(年)后 %ld 秒，RTC 应读取到的是1969(年)后 %ld 秒。\n"

#~ msgid "Unable to get the epoch value from the kernel."
#~ msgstr "无法从内核获取纪元(epoch)值。"

#~ msgid "Kernel is assuming an epoch value of %lu\n"
#~ msgstr "内核假设纪元(epoch)值为 %lu\n"

#~ msgid "To set the epoch value, you must use the 'epoch' option to tell to what value to set it."
#~ msgstr "要设置纪元(epoch)值，您必须使用“epoch”选项来指定设置的值。"

#~ msgid "Not setting the epoch to %lu - testing only.\n"
#~ msgstr "不会将纪元(epoch)设置为 %lu - 仅用于测试。\n"

#~ msgid "Unable to set the epoch value in the kernel.\n"
#~ msgstr "无法设置内核中的纪元(epoch)值。\n"

#~ msgid "Query or set the hardware clock.\n"
#~ msgstr "查询或设置硬件锁。\n"

#~ msgid ""
#~ " -h, --help           show this help text and exit\n"
#~ " -r, --show           read hardware clock and print result\n"
#~ "     --get            read hardware clock and print drift corrected result\n"
#~ "     --set            set the RTC to the time given with --date\n"
#~ msgstr ""
#~ " -h, --help           显示此帮助并退出\n"
#~ " -r, --show           读取硬件时钟并打印结果\n"
#~ "     --set            将 RTC 设置为 --date 指定的时间\n"

#~ msgid ""
#~ " -s, --hctosys        set the system time from the hardware clock\n"
#~ " -w, --systohc        set the hardware clock from the current system time\n"
#~ "     --systz          set the system time based on the current timezone\n"
#~ "     --adjust         adjust the RTC to account for systematic drift since\n"
#~ "                        the clock was last set or adjusted\n"
#~ msgstr ""
#~ " -s, --hctosys        从硬件时钟设置系统时间\n"
#~ " -w, --systohc        从当前系统时间设置硬件时钟\n"
#~ "     --systz          基于当前时区设置系统时间\n"
#~ "     --adjust         根据自上次时钟设置或调整后的系统漂移\n"
#~ "                        来调整 RTC\n"

#~ msgid ""
#~ "     --getepoch       print out the kernel's hardware clock epoch value\n"
#~ "     --setepoch       set the kernel's hardware clock epoch value to the \n"
#~ "                        value given with --epoch\n"
#~ msgstr ""
#~ "     --getepoch       打印内核的硬件时钟纪元(epoch)值\n"
#~ "     --setepoch       将内核的硬件时钟纪元(epoch)值设置为\n"
#~ "                        --epoch 选项指定的值\n"

#~ msgid ""
#~ "     --predict        predict RTC reading at time given with --date\n"
#~ " -V, --version        display version information and exit\n"
#~ msgstr ""
#~ "     --predict        预测 --date 选项所指定时刻读取到的 RTC 值\n"
#~ " -V, --version        显示版本信息并退出\n"

#~ msgid ""
#~ " -u, --utc            the hardware clock is kept in UTC\n"
#~ "     --localtime      the hardware clock is kept in local time\n"
#~ msgstr ""
#~ " -u, --utc            硬件时钟保持为 UTC 时间\n"
#~ "     --localtime      硬件时钟保持为本地时间\n"

#~ msgid " -f, --rtc <file>     special /dev/... file to use instead of default\n"
#~ msgstr " -f, --rtc <文件>     代替默认文件的特殊 /dev/... 文件\n"

#, fuzzy
#~ msgid ""
#~ "     --update-drift   update drift factor in %1$s (requires\n"
#~ "                        --set or --systohc)\n"
#~ "     --noadjfile      do not access %1$s; this requires the use of\n"
#~ "                        either --utc or --localtime\n"
#~ "     --adjfile <file> specifies the path to the adjust file;\n"
#~ "                        the default is %1$s\n"
#~ msgstr ""
#~ "     --noadjfile      不访问 %s；需要使用 --utc 或 --localtime 选项\n"
#~ "     --adjfile <文件> 指定调整文件的路径；\n"
#~ "                        默认为 %s\n"

#~ msgid ""
#~ "     --test           do not update anything, just show what would happen\n"
#~ " -D, --debug          debugging mode\n"
#~ "\n"
#~ msgstr ""
#~ "     --test           不更新，只显示将进行什么操作\n"
#~ " -D, --debug          调试模式\n"
#~ "\n"

#~ msgid "invalid epoch argument"
#~ msgstr "无效的纪元(epoch)参数"

#~ msgid "%s does not have interrupt functions. "
#~ msgstr "%s 没有中断函数。"

#~ msgid "ioctl() to %s to turn on update interrupts failed unexpectedly"
#~ msgstr "对 %s ioctl() 以打开更新中断意外失败"

#, fuzzy
#~ msgid "To manipulate the epoch value in the kernel, we must access the Linux 'rtc' device driver via the device special file.  This file does not exist on this system."
#~ msgstr "要操作内核中的纪元(epoch)值，必须通过设备特殊文件 %s 访问 Linux “rtc”设备驱动。此系统上不存在该文件。"

#~ msgid "we have read epoch %lu from %s with RTC_EPOCH_READ ioctl.\n"
#~ msgstr "我们使用RTC_EPOCH_READ ioctl 从 %2$s 读取了纪元(epoch) %1$lu。\n"

#~ msgid "The epoch value may not be less than 1900.  You requested %ld"
#~ msgstr "纪元(epoch)值不能小于 1900。您要求了 %ld"

#~ msgid "setting epoch to %lu with RTC_EPOCH_SET ioctl to %s.\n"
#~ msgstr "正通过 RTC_EPOCH_SET ioctl 向 %2$s 设置纪元(epoch) %1$lu。\n"

#~ msgid "The kernel device driver for %s does not have the RTC_EPOCH_SET ioctl."
#~ msgstr "%s 的内核设备驱动没有 RTC_EPOCH_SET ioctl (方法)。"

#~ msgid ""
#~ "%s\n"
#~ "Try `%s --help' for more information."
#~ msgstr ""
#~ "%s\n"
#~ "请使用“%s --help”了解更多信息。"

#~ msgid "Try `%s --help' for more information."
#~ msgstr "请使用“%s --help”了解更多信息。"

#~ msgid ""
#~ "\n"
#~ "Available columns (for --show):\n"
#~ msgstr ""
#~ "\n"
#~ "可用列(用于 --show)：\n"

#~ msgid " -T, --trust-irq <on|off>     make driver to trust irq\n"
#~ msgstr " -T, --trust-irq <on|off>     将驱动设置为信任的中断\n"

#~ msgid "     --version              output version information and exit\n"
#~ msgstr "     --version              输出版本信息并退出\n"

#~ msgid " --version                         show version information and exit\n"
#~ msgstr " --version                         输出版本信息并退出\n"

#~ msgid " --help                            display this help and exit\n"
#~ msgstr " --help                            显示此帮助并退出\n"

#~ msgid " -V          display version information and exit\n"
#~ msgstr " -V          显示版本信息并退出\n"

#~ msgid "failed to add data to output table"
#~ msgstr "向输出表添加数据出错"

#~ msgid "failed to initialize output line"
#~ msgstr "初始化输出行失败"

#~ msgid "Device %s already contains a %s signature."
#~ msgstr "设备 %s 已包含一个 %s 签名。"

#~ msgid "%s: these options are mutually exclusive:"
#~ msgstr "%s：以下选项相互排斥："

#~ msgid " -m, --mtab             search in table of mounted filesystems\n"
#~ msgstr " -m, --mtab             在已挂载文件系统表中搜索\n"

#~ msgid "Suspend access to a filesystem (ext3/4, ReiserFS, JFS, XFS).\n"
#~ msgstr "暂停对文件系统的访问(ext3/4, ReiserFS, JFS, XFS)。\n"

#~ msgid "Clock not changed - testing only.\n"
#~ msgstr "时钟未更改 - 纯测试。\n"

#~ msgid "No --date option specified."
#~ msgstr "未指定  --date 选项。"

#~ msgid "--date argument too long"
#~ msgstr "--date 的参数过长"

#~ msgid ""
#~ "The value of the --date option is not a valid date.\n"
#~ "In particular, it contains quotation marks."
#~ msgstr ""
#~ "--date 选项的参数不是有效的日期。\n"
#~ "具体说，它包含了引号。"

#~ msgid "Issuing date command: %s\n"
#~ msgstr "正在发出 date 命令：%s\n"

#~ msgid "Unable to run 'date' program in /bin/sh shell. popen() failed"
#~ msgstr "无法在 /bin/sh shell 中运行“date”程序。popen() 失败"

#~ msgid "response from date command = %s\n"
#~ msgstr "date 命令的响应为 %s\n"

#~ msgid ""
#~ "The date command issued by %s returned unexpected results.\n"
#~ "The command was:\n"
#~ "  %s\n"
#~ "The response was:\n"
#~ "  %s"
#~ msgstr ""
#~ "%s 发出的 date 命令返回了异常结果。\n"
#~ "命令为：\n"
#~ "  %s\n"
#~ "响应为：\n"
#~ "  %s"

#~ msgid ""
#~ "The date command issued by %s returned something other than an integer where the converted time value was expected.\n"
#~ "The command was:\n"
#~ "  %s\n"
#~ "The response was:\n"
#~ " %s\n"
#~ msgstr ""
#~ "%s 发出的 date 命令返回了意外结果，本应返回包含已转换时间值的一个整数。\n"
#~ "命令为：\n"
#~ "  %s\n"
#~ "响应为：\n"
#~ " %s\n"

#~ msgid "date string %s equates to %ld seconds since 1969.\n"
#~ msgstr "数据字符串 %s 等价于 1969年后 %ld 秒。\n"

#~ msgid "Not setting system clock because running in test mode.\n"
#~ msgstr "将不设置系统时钟，因为正以测试方式运行。\n"

#~ msgid "Not updating adjtime file because of testing mode.\n"
#~ msgstr "将不更新 adjtime 文件，因为正以测试方式运行。\n"

#~ msgid ""
#~ "Would have written the following to %s:\n"
#~ "%s"
#~ msgstr ""
#~ "若执行，将向 %s 写入以下内容：\n"
#~ "%s"

#~ msgid ""
#~ "The kernel keeps an epoch value for the Hardware Clock only on an Alpha machine.\n"
#~ "This copy of hwclock was built for a machine other than Alpha\n"
#~ "(and thus is presumably not running on an Alpha now).  No action taken."
#~ msgstr ""
#~ "只有在 Alpha 计算机上内核才会为硬件时钟保持一个纪元(epoch)值。\n"
#~ "这版 hwclock 程序不是为 Alpha 计算机编译的(因此目前也不打算在 Alpha\n"
#~ " 计算机上运行)。未执行任何操作。"

#~ msgid " -c, --compare        periodically compare the system clock with the CMOS clock\n"
#~ msgstr " -c, --compare        定期将系统时钟与 CMOS 时钟相比较\n"

#~ msgid ""
#~ "     --directisa      access the ISA bus directly instead of %s\n"
#~ "     --badyear        ignore RTC's year because the BIOS is broken\n"
#~ "     --date <time>    specifies the time to which to set the hardware clock\n"
#~ "     --epoch <year>   specifies the year which is the beginning of the\n"
#~ "                        hardware clock's epoch value\n"
#~ msgstr ""
#~ "     --directisa      直接访问 ISA 总线，而非 %s\n"
#~ "     --badyear        忽略  RTC 年份(由于 BIOS 损坏)\n"
#~ "     --date <时间>    指定要设置的硬件时钟时间\n"
#~ "     --epoch <年>     指定作为硬件纪元(epoch)值起始的年份\n"

#~ msgid ""
#~ " -J|--jensen, -A|--arc, -S|--srm, -F|--funky-toy\n"
#~ "      tell hwclock the type of Alpha you have (see hwclock(8))\n"
#~ "\n"
#~ msgstr ""
#~ " -J|--jensen, -A|--arc, -S|--srm, -F|--funky-toy\n"
#~ "      告知 hwclock 您使用的 Alpha 类型(参阅 hwclock(8))\n"
#~ "\n"

#~ msgid "Sorry, only the superuser can use the Hardware Clock."
#~ msgstr "对不起，只有超级用户可以使用硬件时钟。"

#~ msgid "%s takes no non-option arguments.  You supplied %d.\n"
#~ msgstr "%s 不接受无选项的参数。您提供了 %d。\n"

#~ msgid "No usable set-to time.  Cannot set clock."
#~ msgstr "无可用的待设置时间。无法设置时钟。"

#~ msgid "booted from MILO\n"
#~ msgstr "从 MILO 启动\n"

#~ msgid "Ruffian BCD clock\n"
#~ msgstr "Ruffian BCD 时钟\n"

#~ msgid "clockport adjusted to 0x%x\n"
#~ msgstr "时钟端口已调整为 0x%x\n"

#~ msgid "funky TOY!\n"
#~ msgstr "烦人的 TOY！\n"

#~ msgid "atomic %s failed for 1000 iterations!"
#~ msgstr "原子操作 %s 1000 次迭代都失败了！"

#~ msgid "cmos_read(): write to control address %X failed"
#~ msgstr "cmos_read()：写控制地址 %X 失败"

#~ msgid "cmos_read(): read from data address %X failed"
#~ msgstr "cmos_read()：从数据地址 %X 读取失败"

#~ msgid "cmos_write(): write to control address %X failed"
#~ msgstr "cmos_write()：写控制地址 %X 失败"

#~ msgid "cmos_write(): write to data address %X failed"
#~ msgstr "cmos_write(): 读数据地址 %X 失败"

#~ msgid "I failed to get permission because I didn't try."
#~ msgstr "程序未获得权限，因为未尝试获取。"

#~ msgid "unable to get I/O port access:  the iopl(3) call failed."
#~ msgstr "无法访问 I/O 端口：iopl(3) 调用失败。"

#~ msgid "Probably you need root privileges.\n"
#~ msgstr "您可能需要 root 用户权限。\n"

#~ msgid "error: can not set signal handler"
#~ msgstr "错误：无法设置信号处理函数"

#~ msgid "error: can not restore signal handler"
#~ msgstr "错误：无法恢复信号处理函数"

#~ msgid "only root can mount %s on %s"
#~ msgstr "只有 root 能将 %s 挂载到 %s"

#~ msgid "%s is used as read only loop, mounting read-only"
#~ msgstr "%s 正用于只读回环，将以只读方式挂载"

#~ msgid ""
#~ "%s: more filesystems detected. This should not happen,\n"
#~ "       use -t <type> to explicitly specify the filesystem type or\n"
#~ "       use wipefs(8) to clean up the device."
#~ msgstr ""
#~ "%s：检测到更多文件系统。这不应该出现，\n"
#~ "       请使用 -t <类型> 指明文件系统类型或\n"
#~ "       使用 wipefs(8) 清理该设备。"

#~ msgid "I could not determine the filesystem type, and none was specified"
#~ msgstr "程序无法检测文件系统类型，并且您未指定类型"

#~ msgid "you must specify the filesystem type"
#~ msgstr "您必须指明文件系统类型"

#~ msgid "mount source not defined"
#~ msgstr "未定义挂臷源"

#~ msgid "%s: mount failed"
#~ msgstr "%s：挂载失败"

#~ msgid "%s: filesystem mounted, but mount(8) failed"
#~ msgstr "%s：文件系统已挂载，但 mount(8) 失败"

#~ msgid "%s is busy"
#~ msgstr "%s 忙"

#~ msgid "       %s is already mounted on %s\n"
#~ msgstr "       %s 已经挂载到 %s 上\n"

#~ msgid "%s not mounted or bad option"
#~ msgstr "%s 未挂载或选项有误"

#~ msgid ""
#~ "       (for several filesystems (e.g. nfs, cifs) you might\n"
#~ "       need a /sbin/mount.<type> helper program)\n"
#~ msgstr ""
#~ "       (对某些文件系统(如 nfs、cifs) 您可能需要\n"
#~ "       一款 /sbin/mount.<类型> 助手程序)\n"

#~ msgid ""
#~ "\n"
#~ "       In some cases useful info is found in syslog - try\n"
#~ "       dmesg | tail or so.\n"
#~ msgstr ""
#~ "\n"
#~ "       有些情况下在 syslog 中可以找到一些有用信息- 请尝试\n"
#~ "       dmesg | tail  这样的命令看看。\n"

#~ msgid "unrecognized option '%c'"
#~ msgstr "不识别的选项“%c”"

#~ msgid "%s: umount failed"
#~ msgstr "%s：umount 失败"

#~ msgid ""
#~ "%s: target is busy\n"
#~ "        (In some cases useful info about processes that\n"
#~ "         use the device is found by lsof(8) or fuser(1).)"
#~ msgstr ""
#~ "%s：目标忙。\n"
#~ "        (有些情况下通过 lsof(8) 或 fuser(1) 可以\n"
#~ "         找到有关使用该设备的进程的有用信息。)"

#~ msgid "%s: mountpoint not found"
#~ msgstr "%s：找不到挂臷点"

#~ msgid "line %d is too long, output will be truncated"
#~ msgstr "第 %d 行过长，输出将截短"

#~ msgid "incomplete write to \"%s\" (written %zd, expected %zd)\n"
#~ msgstr "不完整写入“%s”(写入 %zd，应为 %zd)\n"

#~ msgid "%s: cannot add inotify watch (limit of inotify watches was reached)."
#~ msgstr "%s：无法添加 inotify 观察(达到了 inotify 观察数限制)。"

#~ msgid " %s [option] <file>\n"
#~ msgstr " %s [选项] <文件>\n"

#~ msgid "Follow the growth of a log file.\n"
#~ msgstr "追踪日志文件增长。\n"

#~ msgid " -n, --lines <number>   output the last <number> lines\n"
#~ msgstr " -n, --lines <数字>     输出最后若干行\n"

#~ msgid " -<number>              same as '-n <number>'\n"
#~ msgstr " -<数字>                同“-n <数字>”\n"

#~ msgid "Warning: use of 'tailf' is deprecated, use 'tail -f' instead.\n"
#~ msgstr "警告：“tailf”已废弃，请转用“tail -f”。\n"

#~ msgid "no input file specified"
#~ msgstr "未指定输入文件"

#~ msgid "%s: is not a file"
#~ msgstr "%s︰ 不是一个文件"

#, fuzzy
#~| msgid "filesystem label"
#~ msgid "Filesystem label:"
#~ msgstr "文件系统标签"

#~ msgid "%s is not a block special device"
#~ msgstr "%s 不是一个块特殊设备"

#~ msgid "%s: device is misaligned"
#~ msgstr "%s：设备未正确对齐"

#~ msgid "OS/2 hidden C: drive"
#~ msgstr "OS/2 隐藏的 C: 盘"

#~ msgid "failed to set PATH"
#~ msgstr "设置 PATH 失败"

#~ msgid "%d"
#~ msgstr "%d"

#~ msgid "%s: parse error at line %d"
#~ msgstr "%s：第 %d 行解析出错"

#~ msgid "use of 'kill --pid' option as command name is deprecated"
#~ msgstr "将“kill --pid”选项当作命令的做法已经废弃"

#~ msgid "%s: failed to get device path"
#~ msgstr "%s：获取设备路径失败"

#~ msgid "%s: unknown device name"
#~ msgstr "%s：未知设备名称"

#~ msgid "%s: failed to get dm name"
#~ msgstr "%s：获取 dm 名称失败"

#~ msgid "the sort column has to be among the output columns"
#~ msgstr "排序列必须是输出的列"

#~ msgid ""
#~ " -p, --pid <path>        path to pid file\n"
#~ " -s, --socket <path>     path to socket\n"
#~ " -T, --timeout <sec>     specify inactivity timeout\n"
#~ " -k, --kill              kill running daemon\n"
#~ " -r, --random            test random-based generation\n"
#~ " -t, --time              test time-based generation\n"
#~ " -n, --uuids <num>       request number of uuids\n"
#~ " -P, --no-pid            do not create pid file\n"
#~ " -F, --no-fork           do not daemonize using double-fork\n"
#~ " -S, --socket-activation do not create listening socket\n"
#~ " -d, --debug             run in debugging mode\n"
#~ " -q, --quiet             turn on quiet mode\n"
#~ " -V, --version           output version information and exit\n"
#~ " -h, --help              display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -p, --pid <路径>        pid 文件路径\n"
#~ " -s, --socket <路径>     套接字路径\n"
#~ " -T, --timeout <秒数>    指定不活动超时\n"
#~ " -k, --kill              杀死运行进程\n"
#~ " -r, --random            测试基于随机数的生成方法\n"
#~ " -t, --time              测试基于时间的生成方法\n"
#~ " -n, --uuids <数字>      指定 uuid 号\n"
#~ " -P, --no-pid            不创建 pid 文件\n"
#~ " -F, --no-fork           不使用双 fork 变成守护进程\n"
#~ " -S, --socket-activation 不创建侦听套接字\n"
#~ " -d, --debug             以调试模式运行\n"
#~ " -q, --quiet             打开安静模式\n"
#~ " -V, --version           输出版本信息并退出\n"
#~ " -h, --help              显示此帮助并退出\n"
#~ "\n"

#~ msgid "unknown scheduling policy"
#~ msgstr "未知的调度策略"

#, fuzzy
#~| msgid ""
#~| " -o, --offset <num>  offset in bytes to discard from\n"
#~| " -l, --length <num>  length of bytes to discard from the offset\n"
#~| " -s, --secure        perform secure discard\n"
#~| " -v, --verbose       print aligned length and offset\n"
#~ msgid ""
#~ " -o, --offset <num>  offset in bytes to discard from\n"
#~ " -l, --length <num>  length of bytes to discard from the offset\n"
#~ " -p, --step <num>    size of the discard iterations within the offset\n"
#~ " -s, --secure        perform secure discard\n"
#~ " -v, --verbose       print aligned length and offset\n"
#~ msgstr ""
#~ " -o, --offset <数字> 要忽略部分的字节偏移量\n"
#~ " -l, --length <数字> 从偏移位置开始要忽略的字节长度\n"
#~ " -s, --secure        执行安全忽略\n"
#~ " -v, --verbose       打印对齐的长度和偏移\n"

#, fuzzy
#~| msgid "%s  %.6f seconds\n"
#~ msgid "%s  .%06d seconds\n"
#~ msgstr "%s  %.6f 秒\n"

#~ msgid "%s: parse error: ignore entry at line %d."
#~ msgstr "%s：解析出错：忽略第 %d 行的记录。"

#~ msgid "pages"
#~ msgstr "页数"

#~ msgid "different"
#~ msgstr "不同"

#~ msgid "same"
#~ msgstr "相同"

#~ msgid "bad timeout value: %s"
#~ msgstr "超时值有误：%s"

#~ msgid "expected a number, but got '%s'"
#~ msgstr "应为数字，但收到了“%s”"

#~ msgid "divisor '%s'"
#~ msgstr "除数“%s”"

#~ msgid "argument error: %s"
#~ msgstr "参数出错：%s"

#~ msgid "tty path %s too long"
#~ msgstr "tty 路径 %s 过长"

#~ msgid "Minimal size is %ju"
#~ msgstr "最小为 %ju"

#~ msgid "Please, select a type to create a new disk label."
#~ msgstr "请选择创建新磁盘标签的类型。"

#~ msgid "Help Screen for cfdisk"
#~ msgstr "cfdisk 帮助页面"

#~ msgid "disk drive."
#~ msgstr "分区。"

#~ msgid "Copyright (C) 2014 Karel Zak <kzak@redhat.com> "
#~ msgstr "Copyright (C) 2014 Karel Zak <kzak@redhat.com> "

#~ msgid "Based on the original cfdisk from Kevin E. Martin & aeb."
#~ msgstr "基于由 Kevin E. Martin & aeb 编写的原 cfdisk。"

#~ msgid "             `no'"
#~ msgstr "             写入"

#~ msgid "Device open in read-only mode"
#~ msgstr "设备以只读方式打开"

#~ msgid "Usage: %s [options] device\n"
#~ msgstr "用法：%s [选项] 设备\n"

#~ msgid ""
#~ "\n"
#~ "Options:\n"
#~ " -n, --no-verify  disable the verification after the format\n"
#~ " -V, --version    output version information and exit\n"
#~ " -h, --help       display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "选项：\n"
#~ " -n, --no-verify  禁止格式化后的校验\n"
#~ " -V, --version    输出版本信息并退出\n"
#~ " -h, --help       显示此帮助并退出\n"
#~ "\n"

#~ msgid "stat failed %s"
#~ msgstr "stat 失败：%s"

#~ msgid " -v  be verbose\n"
#~ msgstr " -v  详尽输出\n"

#~ msgid "Usage:\n"
#~ msgstr "用法：\n"

#~ msgid ""
#~ "\n"
#~ "For more information see mkfs(8).\n"
#~ msgstr ""
#~ "\n"
#~ "更多信息请参阅 mkfs(8)。\n"

#~ msgid ""
#~ "Very long (%zu bytes) filename `%s' found.\n"
#~ " Please increase MAX_INPUT_NAMELEN in mkcramfs.c and recompile.  Exiting."
#~ msgstr ""
#~ "发现超长的(%zu 字节)文件名“%s”。\n"
#~ " 请增加 mkcramfs.c 中 MAX_INPUT_NAMELEN 的值并重新编译。将退出。"

#~ msgid "Usage: %s [-c | -l filename] [-nXX] [-iXX] /dev/name [blocks]"
#~ msgstr "用法：%s [-c | -l 文件名] [-nXX] [-iXX] /dev/name [块数]"

#~ msgid "%s: unable to allocate buffer for superblock"
#~ msgstr "%s：不能为超级块分配缓冲区"

#~ msgid "%s: unable to allocate buffers for maps"
#~ msgstr "%s：不能为 maps 分配缓冲区"

#~ msgid "%s: unable to allocate buffer for inodes"
#~ msgstr "%s：不能为 inodes 分配缓冲区"

#~ msgid "%s (%s)\n"
#~ msgstr "%s (%s)\n"

#~ msgid "%s: bad inode size"
#~ msgstr "%s：不正确的 inode 大小"

#~ msgid "Bad swap header size, no label written."
#~ msgstr "交换头(header)大小有误，未写入标签。"

#~ msgid "seek error on %s - cannot seek to %lu"
#~ msgstr "在 %s 上定位出错 - 无法定位到 %lu"

#~ msgid "seek error: wanted 0x%08x%08x, got 0x%08x%08x"
#~ msgstr "定位出错：想要 0x%08x%08x，得到了 0x%08x%08x"

#~ msgid "read error on %s - cannot read sector %llu"
#~ msgstr "在 %s 上定位出错 - 无法定位到 %llu"

#~ msgid "write error on %s - cannot write sector %llu"
#~ msgstr "在 %s 上定位出错 - 无法定位到 %llu"

#~ msgid "cannot open partition sector save file (%s)"
#~ msgstr "打不开分区扇区保存文件(%s)"

#~ msgid "write error on %s"
#~ msgstr "%s 写出错"

#~ msgid "cannot stat partition restore file (%s)"
#~ msgstr "无法 stat 分区恢复文件(%s)"

#~ msgid "partition restore file has wrong size - not restoring"
#~ msgstr "分区恢复文件大小有误 - 将不恢复"

#~ msgid "cannot open partition restore file (%s)"
#~ msgstr "无法打开分区恢复文件(%s)"

#~ msgid "error reading %s"
#~ msgstr "读 %s 出错"

#~ msgid "cannot open device %s for writing"
#~ msgstr "不能打开 %s 以写入"

#~ msgid "error writing sector %lu on %s"
#~ msgstr "写 %2$s 上的 %1$lu 扇区出错"

#~ msgid "Disk %s: cannot get geometry"
#~ msgstr "磁盘 %s：无法获取几何属性"

#~ msgid "Disk %s: cannot get size"
#~ msgstr "磁盘 %s：无法获取尺寸"

#~ msgid ""
#~ "Warning: start=%lu - this looks like a partition rather than\n"
#~ "the entire disk. Using fdisk on it is probably meaningless.\n"
#~ "[Use the --force option if you really want this]"
#~ msgstr ""
#~ "警告：起点为%lu - 这似乎是一个分区，而不是整个盘。对它执行\n"
#~ "fdisk 可能没有意义。[如果您真想这么做，请使用 --force 选项]"

#~ msgid "Warning: HDIO_GETGEO says that there are %lu heads"
#~ msgstr "警告：HDIO_GETGEO 表明有 %lu 个磁头"

#~ msgid "Warning: HDIO_GETGEO says that there are %lu sectors"
#~ msgstr "警告：HDIO_GETGEO 表明有 %lu 个扇区"

#~ msgid "Warning: BLKGETSIZE/HDIO_GETGEO says that there are %lu cylinders"
#~ msgstr "警告：BLKGETSIZE/HDIO_GETGEO 表明有 %lu 个柱面"

#~ msgid ""
#~ "Warning: unlikely number of sectors (%lu) - usually at most 63\n"
#~ "This will give problems with all software that uses C/H/S addressing."
#~ msgstr ""
#~ "警告：扇区数异常(%lu) - 通常最多是 63\n"
#~ "这会给所有使用 C/H/S 地址的软件带来问题。"

#~ msgid ""
#~ "\n"
#~ "Disk %s: %lu cylinders, %lu heads, %lu sectors/track\n"
#~ msgstr ""
#~ "\n"
#~ "磁盘 %s：%lu 个柱面，%lu 个磁头，%lu 个扇区/磁道\n"

#~ msgid "%s of partition %s has impossible value for head: %lu (should be in 0-%lu)"
#~ msgstr "分区 %2$s 的 %1$s 的磁头数有误：%3$lu (应在 0-%4$lu 范围)"

#~ msgid "%s of partition %s has impossible value for sector: %lu (should be in 1-%lu)"
#~ msgstr "分区 %2$s 的 %1$s 的扇区数有误：%3$lu (应在 1-%4$lu 范围)"

#~ msgid "%s of partition %s has impossible value for cylinders: %lu (should be in 0-%lu)"
#~ msgstr "分区 %2$s 的 %1$s 的柱面数有误：%3$lu (应在 0-%4$lu 范围)"

#~ msgid "Re-reading the partition table ...\n"
#~ msgstr "正在重新读取分区表...;\n"

#~ msgid ""
#~ "The command to re-read the partition table failed.\n"
#~ "Run partprobe(8), kpartx(8) or reboot your system now,\n"
#~ "before using mkfs"
#~ msgstr ""
#~ "重新读取分区表的命令失败。\n"
#~ "在使用 mkfs 前，请先运行 partprobe(8)、kpartx(8) 或\n"
#~ "重启系统。"

#~ msgid "Error closing %s"
#~ msgstr "关闭 %s 出错"

#~ msgid "%s: no such partition\n"
#~ msgstr "%s：没有此分区\n"

#~ msgid "unrecognized format - using sectors"
#~ msgstr "无法识别的格式 - 将使用扇区"

#~ msgid "unimplemented format - using %s"
#~ msgstr "未实现的格式 - 将使用 %s"

#~ msgid "sectors"
#~ msgstr "扇区"

#~ msgid ""
#~ "Units: cylinders of %lu bytes, blocks of 1024 bytes, counting from %d\n"
#~ "\n"
#~ msgstr ""
#~ "单位：%lu 的柱面，1024字节的块，从 %d 开始计算\n"
#~ "\n"

#~ msgid "   Device Boot Start     End   #cyls    #blocks   Id  System\n"
#~ msgstr "   设备   启动 开头      结束  #柱面    #块       Id  系统\n"

#~ msgid ""
#~ "Units: sectors of 512 bytes, counting from %d\n"
#~ "\n"
#~ msgstr ""
#~ "单位：512字节的扇区，从 %d 开始计算\n"
#~ "\n"

#~ msgid "   Device Boot    Start       End   #sectors  Id  System\n"
#~ msgstr "   设备   启动    开头        结束  #扇区     Id  系统\n"

#~ msgid ""
#~ "Units: blocks of 1024 bytes, counting from %d\n"
#~ "\n"
#~ msgstr ""
#~ "单位：1024字节的块，从 %d 开始计算\n"
#~ "\n"

#~ msgid "   Device Boot   Start       End    #blocks   Id  System\n"
#~ msgstr "   设备   启动   开头        结束   #块       Id  系统\n"

#~ msgid ""
#~ "Units: 1MiB = 1024*1024 bytes, blocks of 1024 bytes, counting from %d\n"
#~ "\n"
#~ msgstr ""
#~ "单位：1MiB = 1024*1024 字节，1024字节的块，从 %d 开始计算\n"
#~ "\n"

#~ msgid "   Device Boot Start   End    MiB    #blocks   Id  System\n"
#~ msgstr "   设备   启动 开头    结束   MiB    #块       Id  系统\n"

#~ msgid "\t\tstart: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n"
#~ msgstr "\t\t开头：(c,h,s) 应为 (%ld,%ld,%ld) 找到的为 (%ld,%ld,%ld)\n"

#~ msgid "\t\tend: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n"
#~ msgstr "\t\t结束：(c,h,s) 应为 (%ld,%ld,%ld) 找到的为 (%ld,%ld,%ld)\n"

#~ msgid "partition ends on cylinder %ld, beyond the end of the disk\n"
#~ msgstr "分区结束在柱面 %ld，超过了磁盘的末尾\n"

#~ msgid ""
#~ "Warning: The partition table looks like it was made\n"
#~ "  for C/H/S=*/%ld/%ld (instead of %ld/%ld/%ld).\n"
#~ "For this listing I'll assume that geometry."
#~ msgstr ""
#~ "警告：分区表似乎是为 C/H/S=*/%ld/%ld 制作的\n"
#~ "(而非 %ld/%ld/%ld)。\n"
#~ "对这次列表程序将使用该几何属性。"

#~ msgid "no partition table present"
#~ msgstr "不存在分区表"

#~ msgid "strange, only %d partition defined"
#~ msgid_plural "strange, only %d partitions defined"
#~ msgstr[0] "异常，只定义了 %d 个分区"

#~ msgid "Warning: partition %s has size 0 but is not marked Empty"
#~ msgstr "警告：分区 %s 大小为 0 但未标记为 空"

#~ msgid "Warning: partition %s has size 0 and is bootable"
#~ msgstr "警告：分区 %s 大小为 0 并且标记了 可启动"

#~ msgid "Warning: partition %s has size 0 and nonzero start"
#~ msgstr "警告：分区 %s 大小为 0 且起始位置不为 0"

#~ msgid "Warning: partitions %s and %s overlap"
#~ msgstr "警告：分区 %s 和 %s 有重叠"

#~ msgid ""
#~ "Warning: partition %s contains part of the partition table (sector %llu),\n"
#~ "and will destroy it when filled"
#~ msgstr "警告：分区 %s 包含部分分区表(%llu)，填充会破坏它。"

#~ msgid "Warning: partition %s starts at sector 0"
#~ msgstr "警告：分区 %s 起始于扇区 0"

#~ msgid "Warning: partition %s extends past end of disk"
#~ msgstr "警告：分区 %s 超出了磁盘终点"

#~ msgid ""
#~ "Warning: partition %s has size %d.%d TB (%llu bytes),\n"
#~ "which is larger than the %llu bytes limit imposed\n"
#~ "by the DOS partition table for %d-byte sectors"
#~ msgstr ""
#~ "警告：分区 %s 大小为 %d.%d TB (%llu 字节)，大于\n"
#~ "%llu 字节(DOS 分区表对 %d-字节扇区的强制限定值)"

#~ msgid ""
#~ "Warning: partition %s starts at sector %llu (%d.%d TB for %d-byte sectors),\n"
#~ "which exceeds the DOS partition table limit of %llu sectors"
#~ msgstr ""
#~ "警告：分区 %s 起点为第 %llu 扇区 (%d.%d TB，对于 %d-字节扇区)，\n"
#~ "这超过了 DOS 分区表 %llu 个扇区的限制"

#~ msgid ""
#~ "Among the primary partitions, at most one can be extended\n"
#~ " (although this is not a problem under Linux)"
#~ msgstr ""
#~ "主分区中只有一个可设为扩展分区\n"
#~ "(尽管 Linux 下不存在这个问题)"

#~ msgid "Warning: partition %s does not start at a cylinder boundary"
#~ msgstr "警告：分区 %s 未起始于柱面边界。"

#~ msgid "Warning: partition %s does not end at a cylinder boundary"
#~ msgstr "警告：分区 %s 未结束于柱面边界。"

#~ msgid ""
#~ "Warning: more than one primary partition is marked bootable (active)\n"
#~ "This does not matter for LILO, but the DOS MBR will not boot this disk."
#~ msgstr ""
#~ "超过一个主分区被标记为 可启动(活动)。这对 LILO 没有影响，但 \n"
#~ "DOS MBR 将无法启动该磁盘。"

#~ msgid ""
#~ "Warning: usually one can boot from primary partitions only\n"
#~ "LILO disregards the `bootable' flag."
#~ msgstr ""
#~ "警告：通常只能从主分区启动\n"
#~ "LILO 会忽略“可启动”标志。"

#~ msgid ""
#~ "Warning: no primary partition is marked bootable (active)\n"
#~ "This does not matter for LILO, but the DOS MBR will not boot this disk."
#~ msgstr ""
#~ "警告：没有一个主分区被标记为 可启动(活动)。这对 LILO 没有影响，但 \n"
#~ "DOS MBR 将无法启动该磁盘。"

#~ msgid "start"
#~ msgstr "起点"

#~ msgid "partition %s: start: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)"
#~ msgstr "分区 %s：起点：(c,h,s) 应为 (%ld,%ld,%ld) 找到的为 (%ld,%ld,%ld)"

#~ msgid "end"
#~ msgstr "末尾"

#~ msgid "partition %s: end: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)"
#~ msgstr "分区 %s：终点：(c,h,s) 应为 (%ld,%ld,%ld) 找到的为 (%ld,%ld,%ld)"

#~ msgid "partition %s ends on cylinder %ld, beyond the end of the disk"
#~ msgstr "分区 %s 结束于 %ld，超出了磁盘的末尾"

#~ msgid ""
#~ "Warning: shifted start of the extd partition from %lld to %lld\n"
#~ "(For listing purposes only. Do not change its contents.)"
#~ msgstr ""
#~ "警告：扩展分区的起点从 %lld 移到了 %lld\n"
#~ "(仅用于列表。不改变其内容。)"

#~ msgid ""
#~ "Warning: extended partition does not start at a cylinder boundary.\n"
#~ "DOS and Linux will interpret the contents differently."
#~ msgstr ""
#~ "警告：扩展分区未开始于柱面边界处。\n"
#~ "DOS 和 Linux 对其内容的解释会有分歧。"

#~ msgid "ERROR: sector %llu does not have an msdos signature"
#~ msgstr "错误：扇区 %llu 没有 msdos 签名"

#~ msgid "too many partitions - ignoring those past nr (%zu)"
#~ msgstr "分区过多 - 将忽略超过 nr (%zu) 的那些分区"

#~ msgid "tree of partitions?"
#~ msgstr "分区树？"

#~ msgid "detected Disk Manager - unable to handle that"
#~ msgstr "检测到磁盘管理器 - 无法处理它"

#~ msgid "DM6 signature found - giving up"
#~ msgstr "找到 DM6 签名 - 将放弃"

#~ msgid "strange..., an extended partition of size 0?"
#~ msgstr "不对呀...，一个大小为 0 的扩展分区?"

#~ msgid "strange..., a BSD partition of size 0?"
#~ msgstr "不对呀...，一个大小为 0 的 BSD 分区?"

#~ msgid "-n flag was given: Nothing changed"
#~ msgstr "指定了 -n 标志：未做更改"

#~ msgid "Failed saving the old sectors - aborting\n"
#~ msgstr "保存旧扇区失败 - 将中止\n"

#~ msgid "Failed writing the partition on %s"
#~ msgstr "写 %s 上的分区失败"

#~ msgid "long or incomplete input line - quitting"
#~ msgstr "输入行太长或不完整 - 将退出"

#~ msgid "input error: `=' expected after %s field"
#~ msgstr "输入错误：%s 字段后应为“=”"

#~ msgid "input error: unexpected character %c after %s field"
#~ msgstr "输入错误：%2$s 字段后出现异常字符 %1$c"

#~ msgid "unrecognized input: %s"
#~ msgstr "无法识别的输入：%s"

#~ msgid "number too big"
#~ msgstr "数字过大"

#~ msgid "trailing junk after number"
#~ msgstr "数字后有垃圾内容"

#~ msgid "no room for partition descriptor"
#~ msgstr "没有空间放置分区描述符"

#~ msgid "cannot build surrounding extended partition"
#~ msgstr "无法创建环绕扩展分区"

#~ msgid "too many input fields"
#~ msgstr "输入字段过多"

#~ msgid "No room for more"
#~ msgstr "空间不足"

#~ msgid "Illegal type"
#~ msgstr "非法类型"

#~ msgid "Warning: given size (%llu) exceeds max allowable size (%llu)"
#~ msgstr "警告：指定大小(%llu)超过了最大允许大小(%llu)"

#~ msgid "Warning: bad partition start (earliest %llu)"
#~ msgstr "警告：分区起点有误(最早 %llu)"

#~ msgid "unrecognized bootable flag - choose - or *"
#~ msgstr "无法识别的可启动标志 - 选择 - 或 *"

#~ msgid "partial c,h,s specification?"
#~ msgstr "不完整的 c,h,s 说明？"

#~ msgid "bad input"
#~ msgstr "输入错误"

#~ msgid "too many partitions"
#~ msgstr "分区过多"

#~ msgid ""
#~ "Input in the following format; absent fields get a default value.\n"
#~ "<start> <size> <type [E,S,L,X,hex]> <bootable [-,*]> <c,h,s> <c,h,s>\n"
#~ "Usually you only need to specify <start> and <size> (and perhaps <type>)."
#~ msgstr ""
#~ "按以下格式输入，未指定的字段将以默认值填充。\n"
#~ "<起始> <大小> <类型 [E,S,L,X,hex]> <可启动 [-,*]> <c,h,s> <c,h,s>\n"
#~ "通常您只须指定 <起始> 和 <大小> (可能还要指定 <类型>)。"

#~ msgid " %s [options] <device>...\n"
#~ msgstr " %s [选项] <设备>...\n"

#~ msgid ""
#~ " -s, --show-size           list size of a partition\n"
#~ " -c, --id                  change or print partition Id\n"
#~ "     --change-id           change Id\n"
#~ "     --print-id            print Id\n"
#~ msgstr ""
#~ " -s, --show-size           列出每个分区的大小\n"
#~ " -c, --id                  更改或打印分区 Id\n"
#~ "     --change-id           更改 Id\n"
#~ "     --print-id            打印 Id\n"

#~ msgid ""
#~ " -l, --list                list partitions of each device\n"
#~ " -d, --dump                idem, but in a format suitable for later input\n"
#~ " -i, --increment           number cylinders etc. from 1 instead of from 0\n"
#~ " -u, --unit <letter>       units to be used; <letter> can be one of\n"
#~ "                             S (sectors), C (cylinders), B (blocks), or M (MB)\n"
#~ msgstr ""
#~ " -l, --list                列出每个设备的分区\n"
#~ " -d, --dump                同上，但以适合稍后输入的格式列出\n"
#~ " -i, --increment           给柱面等计数时从 1 而非从 0 开始\n"
#~ " -u, --unit <字母>         要使用的单位；<字母> 可以是以下之一\n"
#~ "                             S(扇区)，C(柱面)，B(块)或 M(MB)\n"

#~ msgid ""
#~ " -1, --one-only            reserved option that does nothing currently\n"
#~ " -T, --list-types          list the known partition types\n"
#~ " -D, --DOS                 for DOS-compatibility: waste a little space\n"
#~ " -E, --DOS-extended        DOS extended partition compatibility\n"
#~ " -R, --re-read             make the kernel reread the partition table\n"
#~ msgstr ""
#~ " -1, --one-only            预留选项，目前没有作用\n"
#~ " -T, --list-types          列出已知的分区类型\n"
#~ " -D, --DOS                 与 DOS 兼容；会浪费一点空间\n"
#~ " -E, --DOS-extended        与 DOS 扩展分区兼容\n"
#~ " -R, --re-read             让内核重新读取分区表\n"

#~ msgid ""
#~ " -N <number>               change only the partition with this <number>\n"
#~ " -n                        do not actually write to disk\n"
#~ " -O <file>                 save the sectors that will be overwritten to <file>\n"
#~ " -I <file>                 restore sectors from <file>\n"
#~ msgstr ""
#~ " -N <数字>                 只更改分区号为 <数字> 的分区\n"
#~ " -n                        并不真的写入磁盘\n"
#~ " -O <文件>                 将要覆盖的分区保存到 <文件> 中\n"
#~ " -I <文件>                 从 <文件> 恢复扇区\n"

#~ msgid ""
#~ " -V, --verify              check that the listed partitions are reasonable\n"
#~ " -v, --version             display version information and exit\n"
#~ " -h, --help                display this help text and exit\n"
#~ msgstr ""
#~ " -V, --verify              检查列出扇区的有效性\n"
#~ " -v, --version             显示版本信息并退出\n"
#~ " -h, --help                显示此帮助并退出\n"

#~ msgid ""
#~ "\n"
#~ "Dangerous options:\n"
#~ msgstr ""
#~ "\n"
#~ "危险选项：\n"

#~ msgid ""
#~ " -f, --force               disable all consistency checking\n"
#~ "     --no-reread           do not check whether the partition is in use\n"
#~ " -q, --quiet               suppress warning messages\n"
#~ " -L, --Linux               do not complain about things irrelevant for Linux\n"
#~ msgstr ""
#~ " -f, --force               禁止所有一致性检查\n"
#~ "     --no-reread           不检查分区是否正在使用\n"
#~ " -q, --quiet               抑制警告消息输出\n"
#~ " -L, --Linux               不报告与 Linux 无关的事情\n"

#~ msgid ""
#~ " -g, --show-geometry       print the kernel's idea of the geometry\n"
#~ " -G, --show-pt-geometry    print geometry guessed from the partition table\n"
#~ msgstr ""
#~ " -g, --show-geometry       打印内核检测到的几何属性\n"
#~ " -G, --show-pt-geometry    打印从分区表推测出的几何属性\n"

#~ msgid ""
#~ " -A, --activate[=<device>] activate the bootable flag\n"
#~ " -U, --unhide[=<device>]   set partition as unhidden\n"
#~ " -x, --show-extended       also list extended partitions in the output,\n"
#~ "                             or expect descriptors for them in the input\n"
#~ msgstr ""
#~ " -A, --activate[=<设备>]   激活 可启动 标志\n"
#~ " -U, --unhide[=<设备>]     取消分区隐藏\n"
#~ " -x, --show-extended       输出时也列出扩展分区，\n"
#~ "                             或输入时请求提供它们的描述符\n"

#~ msgid ""
#~ "     --leave-last          do not allocate the last cylinder\n"
#~ "     --IBM                 same as --leave-last\n"
#~ msgstr ""
#~ "     --leave-last          不分配最后一个柱面\n"
#~ "     --IBM                 同 --leave-last\n"

#~ msgid ""
#~ "     --in-order            partitions are in order\n"
#~ "     --not-in-order        partitions are not in order\n"
#~ "     --inside-outer        all logicals inside outermost extended\n"
#~ "     --not-inside-outer    not all logicals inside outermost extended\n"
#~ msgstr ""
#~ "     --in-order            分区按顺序\n"
#~ "     --not-in-order        分区不按顺序\n"
#~ "     --inside-outer        所有逻辑分区位于最外的扩展分区内\n"
#~ "     --not-inside-outer    不要求所有逻辑分区位于最外的扩展分区内\n"

#~ msgid ""
#~ "     --nested              every partition is disjoint from all others\n"
#~ "     --chained             like nested, but extended partitions may lie outside\n"
#~ "     --onesector           partitions are mutually disjoint\n"
#~ msgstr ""
#~ "     --nested              每个分区与所有其他分区不相交\n"
#~ "     --chained             与 nested 相似，但扩展分区可以超界\n"
#~ "     --onesector           各分区互不相交\n"

#~ msgid ""
#~ "\n"
#~ "Override the detected geometry using:\n"
#~ " -C, --cylinders <number>  set the number of cylinders to use\n"
#~ " -H, --heads <number>      set the number of heads to use\n"
#~ " -S, --sectors <number>    set the number of sectors to use\n"
#~ msgstr ""
#~ "\n"
#~ "用以下选项覆盖检测到的几何属性：\n"
#~ " -C, --cylinders <数字>    设置要使用的柱面数\n"
#~ " -H, --heads <数字>        设置要使用的磁头数\n"
#~ " -S, --sectors <数字>      设置要使用的扇区数n\n"

#~ msgid " %s%sdevice            list active partitions on device\n"
#~ msgstr " %s%sdevice            列出设备上的活动分区\n"

#~ msgid " %s%sdevice n1 n2 ...  activate partitions n1 ..., inactivate the rest\n"
#~ msgstr " %s%s设备 n1 n2 ...  激活分区 n1 ..., 取消激活其他分区\n"

#~ msgid "invalid number of partitions argument"
#~ msgstr "无效的 分区数 参数"

#~ msgid "cannot open %s\n"
#~ msgstr "打不开 %s\n"

#~ msgid "usage: sfdisk --print-id device partition-number"
#~ msgstr "用法：sfdisk --print-id 设备 分区号"

#~ msgid "usage: sfdisk --change-id device partition-number Id"
#~ msgstr "用法：sfdisk --change-id 设备 分区号 Id"

#~ msgid "usage: sfdisk --id device partition-number [Id]"
#~ msgstr "用法：sfdisk --id 设备 分区号 [Id]"

#~ msgid "can specify only one device (except with -l or -s)"
#~ msgstr "只能指定一台设备(除非指定 -l 或 -s)"

#~ msgid "cannot open %s read-write"
#~ msgstr "不能以读写方式打开 %s"

#~ msgid "cannot open %s for reading"
#~ msgstr "不能以读方式打开 %s"

#~ msgid "%s: OK"
#~ msgstr "%s：OK"

#~ msgid "%s: %ld cylinders, %ld heads, %ld sectors/track\n"
#~ msgstr "%s：%ld 个柱面，%ld 个磁头，%ld 个扇区/磁道\n"

#~ msgid "bad active byte: 0x%x instead of 0x80"
#~ msgstr "错误的 活动 字节：0x%x 而非 0x80"

#~ msgid "Done"
#~ msgstr "完成"

#~ msgid ""
#~ "You have %d active primary partitions. This does not matter for LILO,\n"
#~ "but the DOS MBR will only boot a disk with 1 active partition."
#~ msgstr ""
#~ "您有 %d 个活动的主分区。这对 LILO 没有影响，但 DOS MBR 只能启动带一个活动分区\n"
#~ "的磁盘。"

#~ msgid "partition %s has id %x and is not hidden"
#~ msgstr "分区 %s 标识为 %x，不是隐藏的"

#~ msgid "Bad Id %lx"
#~ msgstr "错误的 Id %lx"

#~ msgid "This disk is currently in use."
#~ msgstr "此分区正在使用中。"

#~ msgid "Fatal error: cannot find %s"
#~ msgstr "致命错误：找不到 %s"

#~ msgid "Warning: %s is not a block device"
#~ msgstr "警告：%s 不是一个块设备"

#~ msgid "OK"
#~ msgstr "正常"

#~ msgid "Partition %d does not exist, cannot change it"
#~ msgstr "分区 %d 不存在，无法更改它"

#~ msgid ""
#~ "I don't like these partitions - nothing changed.\n"
#~ "(If you really want this, use the --force option.)"
#~ msgstr ""
#~ "我不愿这样分区 - 未做更改。\n"
#~ "(如果您真的想这样做，可使用 --force 选项。)"

#~ msgid "I don't like this - probably you should answer No"
#~ msgstr "我不愿这样做 - 建议您取消"

#~ msgid "Are you satisfied with this? [ynq] "
#~ msgstr "这样您满意吗？[ynq] "

#~ msgid "Quitting - nothing changed"
#~ msgstr "将退出 - 未做更改"

#~ msgid "Please answer one of y,n,q\n"
#~ msgstr "请回答 y, n 或 q\n"

#~ msgid ""
#~ "Successfully wrote the new partition table\n"
#~ "\n"
#~ msgstr ""
#~ "成功写入了新分区表\n"
#~ "\n"

#~ msgid ""
#~ "If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)\n"
#~ "to zero the first 512 bytes:  dd if=/dev/zero of=/dev/foo7 bs=512 count=1\n"
#~ "(See fdisk(8).)"
#~ msgstr ""
#~ "如果您创建或更改了 DOS 分区，如 /dev/foo7，请使用 dd(1)\n"
#~ "将前 512 个字节清零：dd if=/dev/zero of=/dev/foo7 bs=512 count=1\n"
#~ "(参阅 fdisk(8)。)"

#~ msgid "gettimeofday failed"
#~ msgstr "gettimeofday 失败"

#~ msgid "sysinfo failed"
#~ msgstr "sysinfo 失败"

#~ msgid "type: %d"
#~ msgstr "类型：%d"

#~ msgid "disk: %.*s"
#~ msgstr "磁盘：%.*s"

#~ msgid "label: %.*s"
#~ msgstr "标签：%.*s"

#~ msgid "flags: %s"
#~ msgstr "标志：%s"

#~ msgid "bytes/sector: %ld"
#~ msgstr "字节/扇区：%ld"

#~ msgid "sectors/track: %ld"
#~ msgstr "扇区/磁道：%ld"

#~ msgid "tracks/cylinder: %ld"
#~ msgstr "磁道/柱面：%ld"

#~ msgid "sectors/cylinder: %ld"
#~ msgstr "扇区/柱面：%ld"

#~ msgid "cylinders: %ld"
#~ msgstr "柱面：%ld"

#~ msgid "rpm: %d"
#~ msgstr "转/分：%d"

#~ msgid "interleave: %d"
#~ msgstr "交错：%d"

#~ msgid "trackskew: %d"
#~ msgstr "磁道螺距：%d"

#~ msgid "cylinderskew: %d"
#~ msgstr "柱面螺距：%d"

#~ msgid "headswitch: %ld (milliseconds)"
#~ msgstr "磁头切换：%ld (毫秒)"

#~ msgid "track-to-track seek: %ld (milliseconds)"
#~ msgstr "跨磁道定位：%ld (毫秒)"

#~ msgid "partitions: %d"
#~ msgstr "分区数：%d"

#~ msgid "You cannot change a partition into an extended one or vice versa. Delete it first."
#~ msgstr "您不能将分区更改为扩展分区或从扩展分区改回。请先删除该分区。"

#~ msgid "If you have created or modified any DOS 6.x partitions, please see the fdisk documentation for additional information."
#~ msgstr "如果您创建或修改了 DOS 6.x 分区，请查阅 cfdisk 手册页面了解其他信息。"

#~ msgid ""
#~ "Label geometry: %d heads, %llu sectors\n"
#~ "                %llu cylinders, %d physical cylinders\n"
#~ "                %d extra sects/cyl, interleave %d:1\n"
#~ msgstr ""
#~ "标签几何属性：  %d 个磁头，%llu 个扇区\n"
#~ "                %llu 个柱面，%d 个物理柱面\n"
#~ "                %d 个额外扇区/柱面，交错 %d:1\n"

#~ msgid ""
#~ "Label geometry: %d rpm, %d alternate and %d physical cylinders,\n"
#~ "                %d extra sects/cyl, interleave %d:1"
#~ msgstr ""
#~ "标签任何属性：%d rpm, %d 个备用柱面和 %d 个物理柱面，\n"
#~ "                %d 个额外扇区/柱面，交错 %d:1"

#~ msgid "<none>"
#~ msgstr "<无>"

#~ msgid "field is too long"
#~ msgstr "字段过长"

#~ msgid "%s: '%c' is not allowed"
#~ msgstr "%s：不允许“%c”"

#~ msgid "'%c' is not allowed"
#~ msgstr "'%c' 不允许使用"

#~ msgid "%s: control characters are not allowed"
#~ msgstr "%s：不允许使用控制字符"

#~ msgid "control characters are not allowed"
#~ msgstr "不允许使用控制字符"

#~ msgid "usage: last [-#] [-f file] [-t tty] [-h hostname] [user ...]\n"
#~ msgstr "用法：last [-#] [-f 文件] [-t tty] [-h 主机名] [用户 ...]\n"

#~ msgid "%s: mmap failed"
#~ msgstr "%s：mmap 失败"

#~ msgid "  still logged in"
#~ msgstr "  仍然登录"

#~ msgid ""
#~ "\n"
#~ "wtmp begins %s"
#~ msgstr ""
#~ "\n"
#~ "wtmp 开始 %s"

#~ msgid "gethostname failed"
#~ msgstr "gethostname 失败"

#~ msgid ""
#~ "\n"
#~ "interrupted %10.10s %5.5s \n"
#~ msgstr ""
#~ "\n"
#~ "中断了 %10.10s %5.5s \n"

#~ msgid " -m, --supp-groups        display supplementary groups as well\n"
#~ msgstr " -m, --supp-groups        也显示附属组\n"

#~ msgid ""
#~ "\n"
#~ "For more details see lslogins(1).\n"
#~ msgstr ""
#~ "\n"
#~ "更多细节参见 lslogins(1)。\n"

#~ msgid "crypt() failed"
#~ msgstr "crypt() 失败"

#~ msgid "%s: stat failed"
#~ msgstr "%s：stat 失败"

#~ msgid " -h, --help                   This small usage guide\n"
#~ msgstr " -h, --help                   这个简短的用法指南\n"

#~ msgid " -V, --version                Output version information\n"
#~ msgstr " -V, --version                输出版本信息\n"

#~ msgid ""
#~ " -a, --alternative      use alternative dictionary\n"
#~ " -d, --alphanum         compare only alphanumeric characters\n"
#~ " -f, --ignore-case      ignore case differences when comparing\n"
#~ " -t, --terminate <char> define string termination character\n"
#~ " -V, --version          output version information and exit\n"
#~ " -h, --help             display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -a, --alternative      使用替代词典\n"
#~ " -d, --alphanum         只比较字母和数字\n"
#~ " -f, --ignore-case      比较时忽略大小写\n"
#~ " -t, --terminate <字符> 定义字符串终止字符\n"
#~ " -V, --version          输出版本信息并退出\n"
#~ " -h, --help             显示此帮助并退出\n"
#~ "\n"

#~ msgid ""
#~ " -p, --pid <pid>        process id\n"
#~ " -o, --output <list>    define which output columns to use\n"
#~ " -n, --noheadings       don't print headings\n"
#~ " -r, --raw              use the raw output format\n"
#~ " -u, --notruncate       don't truncate text in columns\n"
#~ " -h, --help             display this help and exit\n"
#~ " -V, --version          output version information and exit\n"
#~ msgstr ""
#~ " -p, --pid <pid>        进程标识 ID\n"
#~ " -o, --output <列表>    定义要使用哪些输出列\n"
#~ " -n, --noheadings       不打印标题\n"
#~ " -r, --raw              使用原生输出格式\n"
#~ " -u, --notruncate       不截断列中的文本\n"
#~ " -h, --help             显示此帮助并退出\n"
#~ " -V, --version          输出版本信息并退出\n"

#~ msgid ""
#~ "\n"
#~ "For more information see namei(1).\n"
#~ msgstr ""
#~ "\n"
#~ "更多信息参见 namei(1)。\n"

#~ msgid "%s: lstat failed"
#~ msgstr "%s：lstat 失败"

#~ msgid ""
#~ "\n"
#~ "For more information see wipefs(8).\n"
#~ msgstr ""
#~ "\n"
#~ "更多信息请参阅 wipefs(8)。\n"

#~ msgid ""
#~ "\n"
#~ "Scheduling policies:\n"
#~ "  -b | --batch         set policy to SCHED_BATCH\n"
#~ "  -f | --fifo          set policy to SCHED_FIFO\n"
#~ "  -i | --idle          set policy to SCHED_IDLE\n"
#~ "  -o | --other         set policy to SCHED_OTHER\n"
#~ "  -r | --rr            set policy to SCHED_RR (default)\n"
#~ msgstr ""
#~ "\n"
#~ "调度策略：\n"
#~ "  -b | --batch         设置为 SCHED_BATCH 策略\n"
#~ "  -f | --fifo          设置为 SCHED_FIFO 策略\n"
#~ "  -i | --idle          设置为 SCHED_IDLE 策略\n"
#~ "  -o | --other         设置为 SCHED_OTHER 策略\n"
#~ "  -r | --rr            设置为 SCHED_RR 策略(默认)\n"

#~ msgid ""
#~ "\n"
#~ "Options:\n"
#~ "  -a | --all-tasks     operate on all the tasks (threads) for a given pid\n"
#~ "  -h | --help          display this help\n"
#~ "  -m | --max           show min and max valid priorities\n"
#~ "  -p | --pid           operate on existing given pid\n"
#~ "  -v | --verbose       display status information\n"
#~ "  -V | --version       output version information\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "选项：\n"
#~ "  -a | --all-tasks     在给定 pid 的所有任务(线程)上操作\n"
#~ "  -h | --help          显示此帮助\n"
#~ "  -m | --max           显示最小和最大有效优先级\n"
#~ "  -p | --pid           在存在的指定 pid 上操作\n"
#~ "  -v | --verbose       显示状态信息\n"
#~ "  -V | --version       输出版本信息\n"
#~ "\n"

#~ msgid ""
#~ "\n"
#~ "For more information see taskset(1).\n"
#~ msgstr ""
#~ "\n"
#~ "更多信息请参阅 taskset(1)。\n"

#~ msgid "invalid argument to --manualeject/-i option"
#~ msgstr "--manualeject/-i 选项的参数无效"

#~ msgid "%s: is removable device"
#~ msgstr "%s 不是可移动设备"

#~ msgid "%s: connected by hotplug subsystem: %s"
#~ msgstr "%s：已通过热插拔子系统连接：%s"

#~ msgid "timeout cannot be zero"
#~ msgstr "超时不能为零"

#~ msgid "Need to insert %d second and refer time back %.6f seconds ago\n"
#~ msgid_plural "Need to insert %d seconds and refer time back %.6f seconds ago\n"
#~ msgstr[0] "需要插入 %d 秒并将时间往回指 %.6f 秒\n"

#~ msgid "Sorry, only the superuser can change the System Clock."
#~ msgstr "抱歉，只有超级用户才能设置系统时钟。"

#~ msgid "Sorry, only the superuser can change the Hardware Clock epoch in the kernel."
#~ msgstr "抱歉，只有超级用户才能更改内核中的硬件时钟纪元(epoch)。"

#~ msgid "Waiting in loop for time from KDGHWCLK to change\n"
#~ msgstr "正在循环等待来自 KDGHWCLK 的时间更改\n"

#~ msgid "KDGHWCLK ioctl to read time failed"
#~ msgstr "用来读取时间的 KDGHWCLK ioctl 失败"

#~ msgid "KDGHWCLK ioctl to read time failed in loop"
#~ msgstr "在循环中用来读取时间的 KDGHWCLK ioctl 失败"

#~ msgid "ioctl() failed to read time from %s"
#~ msgstr "ioctl() 从 %s 读取时间失败"

#~ msgid "ioctl KDSHWCLK failed"
#~ msgstr "ioctl KDSHWCLK 失败"

#~ msgid "Using the KDGHWCLK interface to m68k clock."
#~ msgstr "将对 m68k 时钟使用 KDGHWCLK 接口。"

#~ msgid "Can't open /dev/tty1 or /dev/vc/1"
#~ msgstr "打不开 /dev/tty1 或 /dev/vc/1"

#~ msgid "KDGHWCLK ioctl failed"
#~ msgstr "KDGHWCLK ioctl 失败"

#~ msgid "read() to %s to wait for clock tick failed"
#~ msgstr "对 %s read() 以等待时钟嘀嗒失败"

#~ msgid ""
#~ "\n"
#~ "For more details see lscpu(1).\n"
#~ msgstr ""
#~ "\n"
#~ "更多信息请参阅 lscpu(1)。\n"

#~ msgid ""
#~ " -h, --help              display this help text and exit\n"
#~ " -i, --internal-only     don't call the mount.<type> helpers\n"
#~ " -l, --show-labels       lists all mounts with LABELs\n"
#~ " -n, --no-mtab           don't write to /etc/mtab\n"
#~ msgstr ""
#~ " -h, --help              显示此帮助并退出\n"
#~ " -i, --internal-only     不调用 mount.<类型> 助手程序\n"
#~ " -l, --show-labels       列出所有带有指定标签的挂载\n"
#~ " -n, --no-mtab           不写 /etc/mtab\n"

#~ msgid ""
#~ " -v, --verbose           say what is being done\n"
#~ " -V, --version           display version information and exit\n"
#~ " -w, --rw, --read-write  mount the filesystem read-write (default)\n"
#~ msgstr ""
#~ " -v, --verbose           打印当前进行的操作\n"
#~ " -V, --version           显示版本信息并退出\n"
#~ " -w, --rw, --read-write  以读写方式挂载文件系统(默认)\n"

#~ msgid " %s [options] <program> [args...]\n"
#~ msgstr " %s [选项] <程序> [参数...]\n"

#~ msgid ""
#~ " -g, --pgrp <id>        interpret argument as process group ID\n"
#~ " -n, --priority <num>   specify the nice increment value\n"
#~ " -p, --pid <id>         interpret argument as process ID (default)\n"
#~ " -u, --user <name|id>   interpret argument as username or user ID\n"
#~ " -h, --help             display help text and exit\n"
#~ " -V, --version          display version information and exit\n"
#~ msgstr ""
#~ " -g, --pgrp <id>        将参数解释为进程组 ID\n"
#~ " -n, --priority <数字>  指定 nice 增加值\n"
#~ " -p, --pid <id>         将参数解释为进程 ID (默认)\n"
#~ " -u, --user <名字|id>   将参数解释为用户名或用户 ID\n"
#~ " -h, --help             显示帮助文本并退出\n"
#~ " -V, --version          显示版本信息并退出\n"

#~ msgid ""
#~ "\n"
#~ "For more information see renice(1).\n"
#~ msgstr ""
#~ "\n"
#~ "更多信息请参阅 renice(1)。\n"

#~ msgid "set rtc alarm failed"
#~ msgstr "设置 rtc 闹钟失败"

#~ msgid "enable rtc alarm failed"
#~ msgstr "启用 rtc 闹钟失败"

#~ msgid "suspend to \"%s\" unavailable"
#~ msgstr "挂起到“%s”不可用"

#~ msgid " %s%s [options] [program [program arguments]]\n"
#~ msgstr " %s%s [选项] [程序 [程序参数]]\n"

#~ msgid ""
#~ " -a, --all                enable all swaps from /etc/fstab\n"
#~ " -d, --discard[=<policy>] enable swap discards, if supported by device\n"
#~ " -e, --ifexists           silently skip devices that do not exist\n"
#~ " -f, --fixpgsz            reinitialize the swap space if necessary\n"
#~ " -p, --priority <prio>    specify the priority of the swap device\n"
#~ " -s, --summary            display summary about used swap devices (DEPRECATED)\n"
#~ "     --show[=<columns>]   display summary in definable table\n"
#~ "     --noheadings         don't print headings, use with --show\n"
#~ "     --raw                use the raw output format, use with --show\n"
#~ "     --bytes              display swap size in bytes in --show output\n"
#~ " -v, --verbose            verbose mode\n"
#~ msgstr ""
#~ " -a, --all              启用 /etc/fstab 中的所有交换区\n"
#~ " -b, --discard[=<策略>] 启用交换丢弃，如果设备支持\n"
#~ " -e, --ifexists         直接跳过不存在的设备\n"
#~ " -f, --fixpgsz          需要时重新初始化交换空间\n"
#~ " -p, --priority <prio>  指定交换设备的优先级为 <prio>\n"
#~ " -s, --summary          显示已使用交换设备的摘要(已废弃)\n"
#~ "     --show[=<列>]      显示可交换表格的摘要\n"
#~ "     --noheadings       不打印标题，与 --show 一起使用\n"
#~ "     --raw              使用原生输出格式，与 --show 一起使用\n"
#~ "     --bytes            在 --show 选项输出中以字节显示交换区大小\n"
#~ " -v, --verbose          详尽模式\n"

#~ msgid " -m, --mount               unshare mounts namespace\n"
#~ msgstr " -m, --mount               取消共享挂载名字空间\n"

#~ msgid " -u, --uts                 unshare UTS namespace (hostname etc)\n"
#~ msgstr " -u, --uts                 取消共享 UTS 名字空间(主机名等)\n"

#~ msgid " -i, --ipc                 unshare System V IPC namespace\n"
#~ msgstr " -i, --ipc                 取消共享 System V IPC 名字空间\n"

#~ msgid " -n, --net                 unshare network namespace\n"
#~ msgstr " -n, --net                 取消共享网络名字空间\n"

#~ msgid "cannot open: %s: %m"
#~ msgstr "无法打开 %s：%m"

#~ msgid "fread failed"
#~ msgstr "fread 失败"

#~ msgid ""
#~ " -V, --version    output version information and exit\n"
#~ " -h, --help       display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -V, --version    输出版本信息并退出\n"
#~ " -h, --help       显示此帮助并退出\n"
#~ "\n"

#~ msgid ""
#~ "\n"
#~ "Usage:\n"
#~ " %s [options] [file ...]\n"
#~ msgstr ""
#~ "\n"
#~ "用法：\n"
#~ " %s [选项] [文件 ...]\n"

#~ msgid ""
#~ " -,  --no-underlining  suppress all underlining\n"
#~ " -2, --half-lines      print all half-lines\n"
#~ " -V, --version         output version information and exit\n"
#~ " -h, --help            display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -,  --no-underlining  抑制所有下划线\n"
#~ " -2, --half-lines      打印所有半线(half-line)\n"
#~ " -V, --version         输出版本信息并退出\n"
#~ " -h, --help            显示此帮助并退出\n"
#~ "\n"

#~ msgid ""
#~ "\n"
#~ "Options:\n"
#~ " -V, --version   output version information and exit\n"
#~ " -h, --help      display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "选项：\n"
#~ " -V, --version   输出版本信息并退出\n"
#~ " -h, --help      显示此帮助并退出\n"
#~ "\n"

#~ msgid "calling hexdump as od has been deprecated in favor of GNU coreutils od"
#~ msgstr "将 hexdump 作为 od 调用的方式已废弃，请转用 GNU coreutils 的 od"

#~ msgid ""
#~ "\n"
#~ "Options:\n"
#~ " -V, --version   output version information and exit\n"
#~ " -h, --help      display this help and exit\n"
#~ msgstr ""
#~ "\n"
#~ "选项：\n"
#~ " -V, --version   输出版本信息并退出\n"
#~ " -h, --help      显示此帮助并退出\n"

#~ msgid ""
#~ "\n"
#~ "For more information see rev(1).\n"
#~ msgstr ""
#~ "\n"
#~ "更多信息请参阅 rev(1)。\n"

#~ msgid ""
#~ "\n"
#~ "Usage:\n"
#~ " %s [option] file\n"
#~ msgstr ""
#~ "\n"
#~ "用法：\n"
#~ " %s [选项] 文件\n"

#~ msgid ""
#~ "\n"
#~ "Options:\n"
#~ " -n, --lines NUMBER  output the last NUMBER lines\n"
#~ " -NUMBER             same as `-n NUMBER'\n"
#~ " -V, --version       output version information and exit\n"
#~ " -h, --help          display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "选项：\n"
#~ " -n, --lines NUMBER  输出最后 NUMBER 行\n"
#~ " -NUMBER             同“-n NUMBER”\n"
#~ " -V, --version       输出版本信息并退出\n"
#~ " -h, --help          显示此帮助并退出\n"
#~ "\n"

#~ msgid " %s [options] file\n"
#~ msgstr " %s [选项] 文件\n"

#~ msgid "can only change local entries."
#~ msgstr "只能更改本地记录。"

#~ msgid "     --time-format <format>  show time stamp using format:\n"
#~ msgstr "     --time-format <格式>    以指定格式显示时间戳：\n"

#~ msgid "                               [notime|short|full|iso]\n"
#~ msgstr "                               [notime|short|full|iso]\n"

#~ msgid "COMMAND not specified."
#~ msgstr "没有指定命令"

#~ msgid " %s [options] pathname [pathname ...]\n"
#~ msgstr " %s [选项] 路径名 [路径名 ...]\n"

#~ msgid "no filename specified."
#~ msgstr "未指定文件名。"

#~ msgid "...back 1 page"
#~ msgstr "...后退 1 页"

#~ msgid "...skipping one line"
#~ msgstr "...跳过一行"

#~ msgid "waidpid failed"
#~ msgstr "waidpid 失败"

#~ msgid " -x, --destination <dir>  extract into directory\n"
#~ msgstr " -x, --destination <目录> 提取到目录\n"

#~ msgid "compiled without -x support"
#~ msgstr "编译时未带有 -x 支持"

#~ msgid "%s: Out of memory!\n"
#~ msgstr "%s：内存不足！\n"

#~ msgid "Unusable"
#~ msgstr "不可用"

#~ msgid "write failed\n"
#~ msgstr "写失败\n"

#~ msgid "Disk has been changed.\n"
#~ msgstr "磁盘已经更改。\n"

#~ msgid "Reboot the system to ensure the partition table is correctly updated.\n"
#~ msgstr "请重启系统来确保分区表正确更新。\n"

#~ msgid ""
#~ "\n"
#~ "WARNING: If you have created or modified any\n"
#~ "DOS 6.x partitions, please see the cfdisk manual\n"
#~ "page for additional information.\n"
#~ msgstr ""
#~ "\n"
#~ "警告：如果您创建或修改了 DOS 6.x 分区，请\n"
#~ "查阅 cfdisk 手册页面了解其他信息。\n"

#~ msgid "FATAL ERROR"
#~ msgstr "致使错误"

#~ msgid "Press any key to exit cfdisk"
#~ msgstr "按任意键退出 cfdisk"

#~ msgid "Cannot seek on disk drive"
#~ msgstr "在磁盘设备上无法定位"

#~ msgid "Cannot read disk drive"
#~ msgstr "无法读磁盘驱动器"

#~ msgid "Cannot write disk drive"
#~ msgstr "无法写磁盘驱动器"

#~ msgid "Too many partitions"
#~ msgstr "分区过多"

#~ msgid "Partition begins before sector 0"
#~ msgstr "分区起始于扇区 0 之前"

#~ msgid "Partition ends before sector 0"
#~ msgstr "分区终止于扇区 0 之前"

#~ msgid "Partition begins after end-of-disk"
#~ msgstr "分区起始于磁盘终点之后"

#~ msgid "Partition ends after end-of-disk"
#~ msgstr "分区终止于磁盘终点之后"

#~ msgid "logical partitions not in disk order"
#~ msgstr "逻辑分区没有按磁盘顺序"

#~ msgid "logical partitions overlap"
#~ msgstr "逻辑分区重叠"

#~ msgid "enlarged logical partitions overlap"
#~ msgstr "扩大的(enlarged)逻辑分区重叠"

#~ msgid "!!!! Internal error creating logical drive with no extended partition !!!!"
#~ msgstr "!!! 内部错误，在没有扩展分区的情况下创建逻辑分区 !!!"

#~ msgid "Cannot create logical drive here -- would create two extended partitions"
#~ msgstr "无法在此创建逻辑分区 -- 将创建两个扩展分区"

#~ msgid "Menu item too long. Menu may look odd."
#~ msgstr "菜单项过长。菜单可能显示异常。"

#~ msgid "Illegal key"
#~ msgstr "非法的键"

#~ msgid "Create a new primary partition"
#~ msgstr "创建新的主分区"

#~ msgid "Create a new logical partition"
#~ msgstr "创建新的逻辑分区"

#~ msgid "Cancel"
#~ msgstr "取消"

#~ msgid "Don't create a partition"
#~ msgstr "不创建分区"

#~ msgid "!!! Internal error !!!"
#~ msgstr "!!! 内部错误 !!!"

#~ msgid "Size (in MB): "
#~ msgstr "大小(MB)："

#~ msgid "Beginning"
#~ msgstr "开头"

#~ msgid "Add partition at beginning of free space"
#~ msgstr "在剩余空间的开头添加分区"

#~ msgid "Add partition at end of free space"
#~ msgstr "在剩余空间的末尾添加分区"

#~ msgid "No room to create the extended partition"
#~ msgstr "没有空间来创建扩展分区"

#~ msgid "No partition table.\n"
#~ msgstr "无分区表。\n"

#~ msgid "No partition table. Starting with zero table."
#~ msgstr "无分区表。将以空表启动。"

#~ msgid "Bad signature on partition table"
#~ msgstr "分区表签名有误"

#~ msgid "Unknown partition table type"
#~ msgstr "未知的分区表类型"

#~ msgid "Do you wish to start with a zero table [y/N] ?"
#~ msgstr "您想以空表开始吗[y/N]？"

#~ msgid "Cannot open disk drive"
#~ msgstr "无法打开磁盘驱动器"

#~ msgid "Opened disk read-only - you have no permission to write"
#~ msgstr "已用只读方式打开磁盘 - 您没有写权限"

#~ msgid "Cannot get disk size"
#~ msgstr "无法获得磁盘大小"

#~ msgid "Bad primary partition"
#~ msgstr "主分区损坏"

#~ msgid "Warning!!  This may destroy data on your disk!"
#~ msgstr "警告！这可能毁坏您磁盘上的数据！"

#~ msgid "Please enter `yes' or `no'"
#~ msgstr "请输入“是”或“否”"

#~ msgid "Writing partition table to disk..."
#~ msgstr "正在将分区表写入磁盘..."

#~ msgid "Wrote partition table to disk"
#~ msgstr "已将分区表写入磁盘"

#~ msgid "Wrote partition table, but re-read table failed.  Run partprobe(8), kpartx(8) or reboot to update table."
#~ msgstr "已写入分区表，但重新读分区表失败。请运行 partprobe(8)、kpartx(8) 或重启来更新分区表。"

#~ msgid "No primary partitions are marked bootable. DOS MBR cannot boot this."
#~ msgstr "没有标记为 可启动 的主分区。DOS MBR 无法启动它。"

#~ msgid "More than one primary partition is marked bootable. DOS MBR cannot boot this."
#~ msgstr "超过一个主分区被标记为 可启动。DOS MBR 无法启动它。"

#~ msgid "Enter filename or press RETURN to display on screen: "
#~ msgstr "输入文件名或按 回车 来显示在屏幕上："

#~ msgid "Disk Drive: %s\n"
#~ msgstr "磁盘驱动器：%s\n"

#~ msgid "Sector 0:\n"
#~ msgstr "扇区 0：\n"

#~ msgid "Sector %d:\n"
#~ msgstr "扇区 %d：\n"

#~ msgid "   None   "
#~ msgstr "   无   "

#~ msgid "   Pri/Log"
#~ msgstr "   主/逻辑"

#~ msgid "   Primary"
#~ msgstr "   主分区"

#~ msgid "   Logical"
#~ msgstr "   逻辑分区"

#~ msgid "(%02X)"
#~ msgstr "(%02X)"

#~ msgid "None"
#~ msgstr "无"

#~ msgid "Partition Table for %s\n"
#~ msgstr "%s 分区表\n"

# 以下三条打印表格的标题行，注意对齐
#~ msgid "               First       Last\n"
#~ msgstr "               起始        终止\n"

#~ msgid " # Type       Sector      Sector   Offset    Length   Filesystem Type (ID) Flag\n"
#~ msgstr " # 类型       扇区        扇区     偏移      长度     文件系统类型 (ID)    标志\n"

#~ msgid "-- ------- ----------- ----------- ------ ----------- -------------------- ----\n"
#~ msgstr "-- ------- ----------- ----------- ------ ----------- -------------------- ----\n"

# 以下三条打印表格的标题行，注意对齐
#~ msgid "         ---Starting----      ----Ending-----    Start     Number of\n"
#~ msgstr "         -----开始------      -----结束------    起点      扇区\n"

#~ msgid " # Flags Head Sect  Cyl   ID  Head Sect  Cyl     Sector    Sectors\n"
#~ msgstr " # 标志  磁头 扇区  柱面  ID  磁头 扇区  柱面    扇区      数量\n"

#~ msgid "-- ----- ---- ---- ----- ---- ---- ---- ----- ----------- -----------\n"
#~ msgstr "-- ----- ---- ---- ----- ---- ---- ---- ----- ----------- -----------\n"

#~ msgid "Raw"
#~ msgstr "原生"

#~ msgid "Print the table using raw data format"
#~ msgstr "以原生数据格式打印该表"

#~ msgid "Print the table ordered by sectors"
#~ msgstr "按扇区顺序打印表"

#~ msgid "Table"
#~ msgstr "表"

#~ msgid "Just print the partition table"
#~ msgstr "直接打印分区表"

#~ msgid "Don't print the table"
#~ msgstr "不打印表"

#~ msgid "Copyright (C) 1994-1999 Kevin E. Martin & aeb"
#~ msgstr "版权所有 (C) 1994-1999 Kevin E. Martin & aeb"

#~ msgid "  g          Change cylinders, heads, sectors-per-track parameters"
#~ msgstr "  g          更改柱面、磁头、每个磁道扇区数等参数"

#~ msgid "             WARNING: This option should only be used by people who"
#~ msgstr "             警告：不要使用此选项，除非您"

#~ msgid "             know what they are doing."
#~ msgstr "             清楚这样做的后果。"

#~ msgid "  m          Maximize disk usage of the current partition"
#~ msgstr "  m          使当前分区的磁盘使用最大化"

#~ msgid "             Note: This may make the partition incompatible with"
#~ msgstr "             注：这可能使该分区与以下系统不兼容"

#~ msgid "             DOS, OS/2, ..."
#~ msgstr "             DOS, OS/2, ..."

#~ msgid "  p          Print partition table to the screen or to a file"
#~ msgstr "  p          打印分区表到屏幕或文件"

#~ msgid "             There are several different formats for the partition"
#~ msgstr "             有几种不同的分区格式"

#~ msgid "             that you can choose from:"
#~ msgstr "             供您选择："

#~ msgid "                r - Raw data (exactly what would be written to disk)"
#~ msgstr "                r - 原生(raw)数据(数据会原样写入磁盘)"

#~ msgid "                s - Table ordered by sectors"
#~ msgstr "                s - 按扇区排序的表"

#~ msgid "  u          Change units of the partition size display"
#~ msgstr "  u          更改分区大小的显示单位"

#~ msgid "             Rotates through MB, sectors and cylinders"
#~ msgstr "             在 MB、扇区数、柱面数之间循环"

#~ msgid "CTRL-L       Redraws the screen"
#~ msgstr "CTRL-L       重绘屏幕"

#~ msgid "  ?          Print this screen"
#~ msgstr "  ?          打印此屏幕"

#~ msgid "Change cylinder geometry"
#~ msgstr "更改柱面几何属性"

#~ msgid "Change head geometry"
#~ msgstr "更改磁头几何属性"

#~ msgid "Change sector geometry"
#~ msgstr "更改扇区几何属性"

#~ msgid "Done with changing geometry"
#~ msgstr "更改几何属性完成"

#~ msgid "Enter the number of cylinders: "
#~ msgstr "请输入柱面数："

#~ msgid "Illegal cylinders value"
#~ msgstr "柱面数值不合法"

#~ msgid "Enter the number of heads: "
#~ msgstr "请输入磁头数："

#~ msgid "Illegal heads value"
#~ msgstr "磁头数值不合法"

#~ msgid "Enter the number of sectors per track: "
#~ msgstr "请输入每个磁道的扇区数："

#~ msgid "Illegal sectors value"
#~ msgstr "扇区数值不合法"

#~ msgid "Enter filesystem type: "
#~ msgstr "请输入文件系统类型："

#~ msgid "Cannot change FS Type to empty"
#~ msgstr "无法将文件系统类型更改为空值"

#~ msgid "Cannot change FS Type to extended"
#~ msgstr "无法将文件系统类型更改为扩展"

#~ msgid "Unk(%02X)"
#~ msgstr "未知(%02X)"

#~ msgid ", NC"
#~ msgstr "，不可用"

#~ msgid "NC"
#~ msgstr "不可用"

#~ msgid "Pri/Log"
#~ msgstr "主/逻辑"

#~ msgid "Unknown (%02X)"
#~ msgstr "未知 (%02X)"

#~ msgid "Disk Drive: %s"
#~ msgstr "磁盘驱动器：%s"

#~ msgid "Size: %lld bytes, %lld MB"
#~ msgstr "大小：%lld 字节，%lld MB"

#~ msgid "Size: %lld bytes, %lld.%lld GB"
#~ msgstr "大小：%lld 字节，%lld.%lld GB"

#~ msgid "Heads: %d   Sectors per Track: %d   Cylinders: %lld"
#~ msgstr "磁头数：%d  每磁道扇区数：%d        柱面数：%lld"

#~ msgid "Part Type"
#~ msgstr "分区类型"

#~ msgid "FS Type"
#~ msgstr "文件系统"

#~ msgid "[Label]"
#~ msgstr "[标签]"

#~ msgid "    Sectors"
#~ msgstr "    扇区"

#~ msgid "  Cylinders"
#~ msgstr "  柱面"

#~ msgid "  Size (MB)"
#~ msgstr "  大小 (MB)"

#~ msgid "  Size (GB)"
#~ msgstr "  大小 (GB)"

#~ msgid "No more partitions"
#~ msgstr "没有更多分区"

#~ msgid "Change disk geometry (experts only)"
#~ msgstr "更改磁盘的几何属性(仅限专业人员)"

#~ msgid "Maximize"
#~ msgstr "最大化"

#~ msgid "Maximize disk usage of the current partition (experts only)"
#~ msgstr "当前分区的最大磁盘使用量(仅限专业人员)"

#~ msgid "Print"
#~ msgstr "打印"

#~ msgid "Change the filesystem type (DOS, Linux, OS/2 and so on)"
#~ msgstr "更改文件系统类型(DOS, Linux, OS/2 等)"

#~ msgid "Units"
#~ msgstr "单位"

#~ msgid "Change units of the partition size display (MB, sect, cyl)"
#~ msgstr "更改分区大小的单位(MB、扇区，柱面)"

#~ msgid "Cannot make this partition bootable"
#~ msgstr "无法将此分区标记为 可启动"

#~ msgid "Cannot delete an empty partition"
#~ msgstr "无法删除空分区"

#~ msgid "Cannot maximize this partition"
#~ msgstr "无法最大化此分区"

#~ msgid "This partition is unusable"
#~ msgstr "此分区无法使用"

#~ msgid "This partition is already in use"
#~ msgstr "此分区已在使用中"

#~ msgid "Cannot change the type of an empty partition"
#~ msgstr "无法更改空分区的类型"

#~ msgid "Illegal command"
#~ msgstr "非法命令"

#~ msgid "Copyright (C) 1994-2002 Kevin E. Martin & aeb\n"
#~ msgstr "版权所有 (C) 1994-2002 Kevin E. Martin & aeb\n"

#~ msgid " -h, --heads <number>      set the number of heads to use\n"
#~ msgstr " -h, --heads <数字>        设置要使用的磁头数\n"

#~ msgid " -g, --guess               guess a geometry from partition table\n"
#~ msgstr " -g, --guess               根据分区表推算几何属性\n"

#~ msgid " -P, --print <r|s|t>       print partition table in specified format\n"
#~ msgstr " -P, --print <r|s|t>       以指定的格式打印分区表\n"

#~ msgid " -a, --arrow               use arrow for highlighting the current partition\n"
#~ msgstr " -a, --arrow               用箭头突出显示当前分区\n"

#~ msgid "cannot parse number of cylinders"
#~ msgstr "无法解析柱面数"

#~ msgid "cannot parse number of heads"
#~ msgstr "无法解析磁头数"

#~ msgid "cannot parse number of sectors"
#~ msgstr "无法解析扇区数"

#~ msgid ": "
#~ msgstr "："

#~ msgid " -b <size>         sector size (512, 1024, 2048 or 4096)\n"
#~ msgstr " -b <size>         扇区大小(512, 1024, 2048 或 4096)\n"

#~ msgid " -h                print this help text\n"
#~ msgstr " -h                显示此帮助并退出\n"

#~ msgid "\n"
#~ msgstr "\n"

#~ msgid "#"
#~ msgstr "#"

#~ msgid "fsize"
#~ msgstr "fsize"

#~ msgid "bsize"
#~ msgstr "bsize"

#~ msgid "Partition %d is already defined.  Delete it before re-adding it."
#~ msgstr "分区 %d 已经定义。请删除它再重新添加。"

#~ msgid ""
#~ "Partition type:\n"
#~ "   p   primary (%zd primary, %d extended, %zd free)\n"
#~ "%s\n"
#~ "Select (default %c)"
#~ msgstr ""
#~ "分区类型：\n"
#~ "   p   主分区(%zd 个主分区，%d 个扩展分区，%zd 空闲)\n"
#~ "%s\n"
#~ "请选择(默认为 %c)："

#~ msgid "   e   extended"
#~ msgstr "   e   扩展分区"

#~ msgid "Nr"
#~ msgstr "Nr"

#~ msgid "AF"
#~ msgstr "AF"

#~ msgid "Hd"
#~ msgstr "Hd"

#~ msgid "Sec"
#~ msgstr "Sec"

#~ msgid "Cyl"
#~ msgstr "Cyl"

#~ msgid "This doesn't look like a partition table. Probably you selected the wrong device."
#~ msgstr "这似乎不是分区表。您可能选错了设备。"

#~ msgid "Blocks "
#~ msgstr "块 "

#~ msgid "System"
#~ msgstr "系统"

#~ msgid "Partition %zd is already defined. Delete it before re-adding it."
#~ msgstr "分区 %zd 已定义。请删除它再重新添加。"

#~ msgid "Pt#"
#~ msgstr "Pt#"

#~ msgid "Info"
#~ msgstr "信息"

#~ msgid "Sector"
#~ msgstr "扇区"

#~ msgid "You will get a partition overlap on the disk. Fix it first!"
#~ msgstr "磁盘上将产生重叠分区。请先修复它！"

#~ msgid "Warning:  BLKGETSIZE ioctl failed on %s. Using geometry cylinder value of %llu. This value may be truncated for devices > 33.8 GB."
#~ msgstr "警告：对 %s 执行 BLKGETSIZE ioctl 失败。将使用柱面值 %llu。对大于 33.8GB 的设备这个值可能会截短。"

#~ msgid "Flag"
#~ msgstr "标志"

#~ msgid ""
#~ " %1$s [options] LABEL=<label>\n"
#~ " %1$s [options] UUID=<uuid>\n"
#~ msgstr ""
#~ " %1$s [选项] LABEL=<label>\n"
#~ " %1$s [选项] UUID=<uuid>\n"

#~ msgid ""
#~ " -A, --all              disable all built-in filters, print all filesystems\n"
#~ " -a, --ascii            use ASCII chars for tree formatting\n"
#~ " -c, --canonicalize     canonicalize printed paths\n"
#~ " -D, --df               imitate the output of df(1)\n"
#~ " -d, --direction <word> direction of search, 'forward' or 'backward'\n"
#~ " -e, --evaluate         convert tags (LABEL,UUID,PARTUUID,PARTLABEL) \n"
#~ "                          to device names\n"
#~ " -F, --tab-file <path>  alternative file for --fstab, --mtab or --kernel options\n"
#~ " -f, --first-only       print the first found filesystem only\n"
#~ msgstr ""
#~ " -A, --all              禁用所有内建过滤器，打印所有文件系统\n"
#~ " -a, --ascii            使用 ASCII 进行树格式化\n"
#~ " -c, --canonicalize     规范输出路径\n"
#~ " -D, --df               仿照 df(1) 形式输出\n"
#~ " -d, --direction <词>   搜索方向，“forward”或“backward”\n"
#~ " -e, --evaluate         将标志(LABEL,UUID,PARTUUID,PARTLABEL)\n"
#~ "                          转换为设备名\n"
#~ " -F, --tab-file <路径>  --fstab、--mtab 或 --kernel 选项的备选文件\n"
#~ " -f, --first-only       只打印找到的第一个文件系统\n"

#~ msgid ""
#~ " -i, --invert           invert the sense of matching\n"
#~ " -l, --list             use list format output\n"
#~ " -N, --task <tid>       use alternative namespace (/proc/<tid>/mountinfo file)\n"
#~ " -n, --noheadings       don't print column headings\n"
#~ " -u, --notruncate       don't truncate text in columns\n"
#~ msgstr ""
#~ " -i, --invert           反转匹配规则\n"
#~ " -l, --list             使用列表格式的输出\n"
#~ " -N, --task <tid>       使用备选名字空间(/proc/<tid>/mountinfo 文件)\n"
#~ " -n, --noheadings       不打印列标题\n"
#~ " -u, --notruncate       不截短列中的文本\n"

#~ msgid ""
#~ " -v, --nofsroot         don't print [/dir] for bind or btrfs mounts\n"
#~ " -R, --submounts        print all submounts for the matching filesystems\n"
#~ " -S, --source <string>  the device to mount (by name, maj:min, \n"
#~ "                          LABEL=, UUID=, PARTUUID=, PARTLABEL=)\n"
#~ " -T, --target <string>  the mountpoint to use\n"
#~ msgstr ""
#~ " -v, --nofsroot         bind 或 btrfs 挂臷时不打印 [/dir]\n"
#~ " -R, --submounts        打印匹配文件系统的所有子挂臷\n"
#~ " -S, --source <字符串>  要挂臷的设备(按名称、主设备号：次设备号、\n"
#~ "                          LABEL=、UUID=、ARTUUID=、ARTLABEL=)\n"
#~ " -T, --target <字符串>  要使用的挂臷点\n"

#~ msgid ""
#~ " -f, --file <file> use file as a cookie seed\n"
#~ " -v, --verbose     explain what is being done\n"
#~ " -V, --version     output version information and exit\n"
#~ " -h, --help        display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -f, --file <文件> 使用指定文件作为 cookie seed\n"
#~ " -v, --verbose     解释正在进行的操作\n"
#~ " -V, --version     输出版本信息并退出\n"
#~ " -h, --help        显示此帮助并退出\n"
#~ "\n"

#~ msgid "Both --pid and --no-pid specified. Ignoring --no-pid."
#~ msgstr "同时指定了 --pid 和 --no-pid。将忽略 --no-pid。"

#~ msgid "warning: error reading %s: %s"
#~ msgstr "警告：读取 %s 出错：%s"

#~ msgid "warning: can't open %s: %s"
#~ msgstr "警告：打不开 %s：%s"

#~ msgid "mount: could not open %s - using %s instead\n"
#~ msgstr "挂载：打不开 %s - 将转用 %s\n"

#~ msgid "can't create lock file %s: %s (use -n flag to override)"
#~ msgstr "无法创建锁文件 %s：%s (可使用 -n 标志覆盖)"

#~ msgid "can't link lock file %s: %s (use -n flag to override)"
#~ msgstr "无法链接锁文件 %s：%s (可使用 -n 标志覆盖)"

#~ msgid "can't open lock file %s: %s (use -n flag to override)"
#~ msgstr "打不开锁文件 %s：%s (可使用 -n 标志覆盖)"

#~ msgid "Can't lock lock file %s: %s\n"
#~ msgstr "无法锁定锁文件 %s：%s\n"

#~ msgid "can't lock lock file %s: %s"
#~ msgstr "无法锁定锁文件 %s：%s"

#~ msgid ""
#~ "Cannot create link %s\n"
#~ "Perhaps there is a stale lock file?\n"
#~ msgstr ""
#~ "无法创建链接 %s\n"
#~ "有一个过期的锁文件吗？\n"

#~ msgid "cannot open %s (%s) - mtab not updated"
#~ msgstr "无法打开 %s (%s) - mtab 未更新"

#~ msgid "error writing %s: %s"
#~ msgstr "写 %s 出错：%s"

#~ msgid "%s: cannot fflush changes: %s"
#~ msgstr "%s：无法 fflush 更改：%s"

#~ msgid "error changing mode of %s: %s\n"
#~ msgstr "更改 %s 的模式出错：%s\n"

#~ msgid "error changing owner of %s: %s\n"
#~ msgstr "更改 %s 的所有者失败：%s\n"

#~ msgid "can't rename %s to %s: %s\n"
#~ msgstr "无法将 %s 改名为 %s：%s\n"

#~ msgid ""
#~ "\n"
#~ "mount: warning: /etc/mtab is not writable (e.g. read-only filesystem).\n"
#~ "       It's possible that information reported by mount(8) is not\n"
#~ "       up to date. For actual information about system mount points\n"
#~ "       check the /proc/mounts file.\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "mount：/etc/mtab 不可写(比如是只读文件系统)。\n"
#~ "       mount(8) 报告的信息可能不是最新的。\n"
#~ "       有关系统挂载点的实际信息请检查\n"
#~ "       /proc/mounts 获取。\n"
#~ "\n"

#~ msgid "mount: improperly quoted option string '%s'"
#~ msgstr "mount：选项字符串“%s”引号没有正确闭合"

#~ msgid "mount: translated %s '%s' to '%s'\n"
#~ msgstr "mount：已将 %s “%s”转换为“%s”\n"

#~ msgid "mount: SELinux *context= options are ignore on remount.\n"
#~ msgstr "mount：SELinux *context= 选项重新挂载会时忽略。\n"

#~ msgid "mount: according to mtab, %s is already mounted on %s"
#~ msgstr "mount：根据 mtab，%s 已挂载于 %s"

#~ msgid "mount: according to mtab, %s is mounted on %s"
#~ msgstr "mount：根据 mtab，%s 挂载于 %s"

#~ msgid "mount: can't open %s for writing: %s"
#~ msgstr "mount：无法打开 %s 进行写入：%s"

#~ msgid "mount: error writing %s: %s"
#~ msgstr "mount：写 %s 出错：%s"

#~ msgid "mount: error changing mode of %s: %s"
#~ msgstr "mount：更改 %s 的模式出错：%s"

#~ msgid "mount: cannot set group id: %m"
#~ msgstr "mount：无法设置组 id：%m"

#~ msgid "mount: cannot set user id: %m"
#~ msgstr "mount：无法设置用户 id：%m"

#~ msgid "mount: cannot fork: %s"
#~ msgstr "mount：无法 fork：%s"

#~ msgid "Trying %s\n"
#~ msgstr "正在尝试 %s\n"

#~ msgid "mount: you didn't specify a filesystem type for %s\n"
#~ msgstr "mount：您没有指定 %s 的文件系统类型\n"

#~ msgid "       I will try all types mentioned in %s or %s\n"
#~ msgstr "       程序将尝试 %s 或 %s 中提到的所有类型\n"

#~ msgid "       and it looks like this is swapspace\n"
#~ msgstr "       这似乎是交换空间\n"

#~ msgid "       I will try type %s\n"
#~ msgstr "       程序将尝试 %s 类型\n"

#~ msgid "%s looks like swapspace - not mounted"
#~ msgstr "%s 似乎是交换空间 - 未挂载"

#~ msgid ""
#~ "mount: %s: more filesystems detected. This should not happen,\n"
#~ "       use -t <type> to explicitly specify the filesystem type or\n"
#~ "       use wipefs(8) to clean up the device.\n"
#~ msgstr ""
#~ "mount：%s：检测到了更多文件系统。这不应该发生， \n"
#~ "       请使用 -t <类型> 来明确指定文件系统类型或\n"
#~ "       使用 wipefs(8) 来清理设备。\n"

#~ msgid "mount: only root can mount %s on %s"
#~ msgstr "mount：只有 root 才能将 %s 挂载于 %s"

#~ msgid "mount: loop device specified twice"
#~ msgstr "mount：回环设备指定了两次"

#~ msgid "mount: type specified twice"
#~ msgstr "mount：类型指定了两次"

#~ msgid "mount: skipping the setup of a loop device\n"
#~ msgstr "mount：将跳过回环设备的设置\n"

#~ msgid "mount: enabling autoclear loopdev flag\n"
#~ msgstr "mount：将启用 自动清除 环回设备标志\n"

#~ msgid "mount: invalid offset '%s' specified"
#~ msgstr "mount：指定了无效的偏移“%s”"

#~ msgid "mount: invalid sizelimit '%s' specified"
#~ msgstr "mount：指定了无效的大小限制“%s”"

#~ msgid "mount: according to mtab %s is already mounted on %s as loop"
#~ msgstr "mount：根据 mtab，%s 已作为回环设备挂载于 %s"

#~ msgid "encryption not supported, use cryptsetup(8) instead"
#~ msgstr "不支持加密，请改用 cryptsetup(8)"

#~ msgid "mount: failed to initialize loopdev context"
#~ msgstr "mount：初始化 loopdev 环境失败"

#~ msgid "mount: failed to use %s device"
#~ msgstr "mount：使用 %s 设备失败"

#~ msgid "mount: failed to found free loop device"
#~ msgstr "mount：查找空闲的回环设备失败"

#~ msgid "mount: going to use the loop device %s\n"
#~ msgstr "mount：将使用回环设备 %s\n"

#~ msgid "mount: %s: failed to set loopdev attributes"
#~ msgstr "mount：%s：设置回环设备属性失败"

#~ msgid "mount: %s: failed setting up loop device: %m"
#~ msgstr "挂臷：%s：设置回环设备失败：%m"

#~ msgid "mount: stolen loop=%s ...trying again\n"
#~ msgstr "mount：被挪用回环=%s ...将重试\n"

#~ msgid "mount: stolen loop=%s"
#~ msgstr "挂载：被挪用回环=%s"

#~ msgid "mount: setup loop device successfully\n"
#~ msgstr "mount：设置回环设备成功\n"

#~ msgid "mount: no %s found - creating it..\n"
#~ msgstr "mount：未找到 %s - 将创建它...\n"

#~ msgid "mount: cannot open %s for setting speed"
#~ msgstr "mount：无法打开 %s 来设置速度"

#~ msgid "mount: cannot set speed: %m"
#~ msgstr "mount：无法设置速度：%m"

#~ msgid "mount: according to mtab, %s is already mounted on %s\n"
#~ msgstr "mount：根据 mtab，%s 已挂载于 %s\n"

#~ msgid "mount: warning: %s seems to be mounted read-write.\n"
#~ msgstr "mounted：警告：%s 似乎是以读写方式挂载的。\n"

#~ msgid "mount: warning: %s seems to be mounted read-only.\n"
#~ msgstr "挂载：警告：%s 似乎是以只读方式挂载的。\n"

#~ msgid "mount: I could not determine the filesystem type, and none was specified"
#~ msgstr "mount：程序无法确定文件系统类型，并且没有指定"

#~ msgid "mount: you must specify the filesystem type"
#~ msgstr "mount：您必须指定文件系统类型"

#~ msgid "mount: mount failed"
#~ msgstr "mount：挂载失败"

#~ msgid "mount: mount point %s is not a directory"
#~ msgstr "mount：挂载点 %s 不是一个目录"

#~ msgid "mount: permission denied"
#~ msgstr "mount：权限不足"

#~ msgid "mount: must be superuser to use mount"
#~ msgstr "mount：必须是超级用户才能使用 mount"

#~ msgid "mount: proc already mounted"
#~ msgstr "mount：proc 已挂载"

#~ msgid "mount: %s already mounted or %s busy"
#~ msgstr "mount：%s 已挂载或 %s 忙"

#~ msgid "mount: mount point %s does not exist"
#~ msgstr "mount：挂载点 %s 不存在"

#~ msgid "mount: mount point %s is a symbolic link to nowhere"
#~ msgstr "mount：挂载点 %s 是一个没有目标位置的符号链接"

#~ msgid "mount: special device %s does not exist"
#~ msgstr "mount：特殊设备 %s 不存在"

#~ msgid ""
#~ "mount: special device %s does not exist\n"
#~ "       (a path prefix is not a directory)\n"
#~ msgstr ""
#~ "mount：特殊设备 %s 不存在\n"
#~ "       (路径前缀不是目录)\n"

#~ msgid ""
#~ "mount: wrong fs type, bad option, bad superblock on %s,\n"
#~ "       missing codepage or helper program, or other error"
#~ msgstr ""
#~ "mount：文件系统类型错误、选项错误、%s 有坏超级块，\n"
#~ "       缺少代码页或助手程序，或其他错误"

#~ msgid ""
#~ "       (could this be the IDE device where you in fact use\n"
#~ "       ide-scsi so that sr0 or sda or so is needed?)"
#~ msgstr ""
#~ "       (这是不是一台通过 ide-scsi 方式使用的 IDE 设备，\n"
#~ "       因而需要 sr0 或 sda 或 so？)"

#~ msgid ""
#~ "       (aren't you trying to mount an extended partition,\n"
#~ "       instead of some logical partition inside?)"
#~ msgstr ""
#~ "       (您不是要试图挂载一个扩展分区，而非扩展分区中的\n"
#~ "       一些逻辑分区吧？)"

#~ msgid ""
#~ "       In some cases useful info is found in syslog - try\n"
#~ "       dmesg | tail  or so\n"
#~ msgstr ""
#~ "       有些情况下在 syslog 中可以找到一些有用信息- 请尝试\n"
#~ "       dmesg | tail  这样的命令看看。\n"

#~ msgid "mount: %s: can't read superblock"
#~ msgstr "mount：%s：无法读取超级块"

#~ msgid "mount: %s: unknown device"
#~ msgstr "mount：%s：未知设备"

#~ msgid "mount: unknown filesystem type '%s'"
#~ msgstr "mount：未知文件系统类型“%s”"

#~ msgid "mount: probably you meant %s"
#~ msgstr "mount：您可能指的是 %s"

#~ msgid "mount: maybe you meant 'iso9660'?"
#~ msgstr "mount：可能您指的是“iso9660”？"

#~ msgid "mount: maybe you meant 'vfat'?"
#~ msgstr "mount：可能您指的是“vfat”？"

#~ msgid "mount: %s has wrong device number or fs type %s not supported"
#~ msgstr "mount：%s 设备号错误或不支持文件系统 %s"

#~ msgid "mount: %s is not a block device, and stat fails?"
#~ msgstr "mount：%s 不是块设备，且 stat 命令失败？"

#~ msgid ""
#~ "mount: the kernel does not recognize %s as a block device\n"
#~ "       (maybe `modprobe driver'?)"
#~ msgstr ""
#~ "mount：内核无法将 %s 识别为块设备\n"
#~ "       (试试“modprobe driver”？)"

#~ msgid "mount: %s is not a block device (maybe try `-o loop'?)"
#~ msgstr "mount：%s 不是块设备(要不试试“-o loop”？)"

#~ msgid "mount: %s is not a block device"
#~ msgstr "mount：%s 不是块设备"

#~ msgid "mount: %s is not a valid block device"
#~ msgstr "mount：%s 不是有效的块设备"

#~ msgid "mount: cannot mount %s%s read-only"
#~ msgstr "mount：无法以只读方式挂载 %s%s"

#~ msgid "mount: %s%s is write-protected but explicit `-w' flag given"
#~ msgstr "mount：%s%s 是写保护的，但指明了“-w”标志"

#~ msgid "mount: cannot remount %s%s read-write, is write-protected"
#~ msgstr "mount：无法以读写方式重新挂载 %s%s，它是写保护的"

#~ msgid "mount: %s%s is write-protected, mounting read-only"
#~ msgstr "mount：%s%s 写保护，将以只读方式挂载"

#~ msgid "mount: no medium found on %s"
#~ msgstr "mount：在 %s 上找不到媒体"

#~ msgid "mount: no type was given - I'll assume nfs because of the colon\n"
#~ msgstr "mount：没有指定类型 - 程序将根据冒号假定为 nfs\n"

#~ msgid "mount: no type was given - I'll assume cifs because of the // prefix\n"
#~ msgstr "mount：没有指定类型 - 程序将根据 // 前缀假定为 cifs\n"

#~ msgid "mount: ignore %s (unparsable offset= option)\n"
#~ msgstr "mount：忽略 %s(无法解析的 offset= 选项)\n"

#~ msgid ""
#~ "Usage: mount -V                 : print version\n"
#~ "       mount -h                 : print this help\n"
#~ "       mount                    : list mounted filesystems\n"
#~ "       mount -l                 : idem, including volume labels\n"
#~ "So far the informational part. Next the mounting.\n"
#~ "The command is `mount [-t fstype] something somewhere'.\n"
#~ "Details found in /etc/fstab may be omitted.\n"
#~ "       mount -a [-t|-O] ...     : mount all stuff from /etc/fstab\n"
#~ "       mount device             : mount device at the known place\n"
#~ "       mount directory          : mount known device here\n"
#~ "       mount -t type dev dir    : ordinary mount command\n"
#~ "Note that one does not really mount a device, one mounts\n"
#~ "a filesystem (of the given type) found on the device.\n"
#~ "One can also mount an already visible directory tree elsewhere:\n"
#~ "       mount --bind olddir newdir\n"
#~ "or move a subtree:\n"
#~ "       mount --move olddir newdir\n"
#~ "One can change the type of mount containing the directory dir:\n"
#~ "       mount --make-shared dir\n"
#~ "       mount --make-slave dir\n"
#~ "       mount --make-private dir\n"
#~ "       mount --make-unbindable dir\n"
#~ "One can change the type of all the mounts in a mount subtree\n"
#~ "containing the directory dir:\n"
#~ "       mount --make-rshared dir\n"
#~ "       mount --make-rslave dir\n"
#~ "       mount --make-rprivate dir\n"
#~ "       mount --make-runbindable dir\n"
#~ "A device can be given by name, say /dev/hda1 or /dev/cdrom,\n"
#~ "or by label, using  -L label  or by uuid, using  -U uuid .\n"
#~ "Other options: [-nfFrsvw] [-o options] [-p passwdfd].\n"
#~ "For many more details, say  man 8 mount .\n"
#~ msgstr ""
#~ "用法： mount -V                 : 打印版本\n"
#~ "       mount -h                 : 打印此帮助\n"
#~ "       mount                    : 列出已挂臷的文件系统\n"
#~ "       mount -l                 : 同上，包含卷标\n"
#~ "以上为信息部分。以下是挂臷。\n"
#~ "挂臷命令为“mount [-t 文件系统类型] 待挂臷项 挂臷位置”。\n"
#~ "在 /etc/fstab 中列出的细节可以忽略。\n"
#~ "       mount -a [-t|-O] ...     : 挂臷 /etc/fstab 中的所有项\n"
#~ "       mount 设备               : 挂臷未知位置的设备\n"
#~ "       mount 目录               : 将已知设备挂臷到此处\n"
#~ "       mount -t 类型 设备 目录  : 正常挂臷命令\n"
#~ "注意，挂臷设备其实是(以指定类型)挂臷设备上的文件系统。\n"
#~ "\n"
#~ "也可以将已经可见的目录树挂臷到别处：\n"
#~ "       mount --bind 旧目录 新目录\n"
#~ "或移动子树：\n"
#~ "       mount --move 旧目录 新目录\n"
#~ "可以改变包含 dir 目录的挂臷的类型：\n"
#~ "       mount --make-shared dir\n"
#~ "       mount --make-slave dir\n"
#~ "       mount --make-private dir\n"
#~ "       mount --make-unbindable dir\n"
#~ "可以指定包含 dir 目录的已挂臷子树中\n"
#~ "所有挂臷的类型：\n"
#~ "       mount --make-rshared dir\n"
#~ "       mount --make-rslave dir\n"
#~ "       mount --make-rprivate dir\n"
#~ "       mount --make-runbindable dir\n"
#~ "可以通过名称指定设备，如 /dev/hda1 或 /dev/cdrom，\n"
#~ "或使用 -L 标签 按标签指定设备，或者使用 -U uuid 按 uuid 指定。\n"
#~ "其他选项：[-nfFrsvw] [-o 选项] [-p 密码文件描述符].\n"
#~ "更多细节，请输入 man 8 mount 了解。\n"

#~ msgid "--pass-fd is no longer supported"
#~ msgstr "--pass-fd 已不再支持"

#~ msgid "mount: only root can do that (effective UID is %u)"
#~ msgstr "挂臷：只有 root 用户才能执行(有效 UID 为 %u)"

#~ msgid "mount: only root can do that"
#~ msgstr "挂臷：只有 root 用户才能执行"

#~ msgid "nothing was mounted"
#~ msgstr "未挂臷任何项目"

#~ msgid "mount: no such partition found"
#~ msgstr "挂臷：没有找到该分区"

#~ msgid "mount: can't find %s in %s or %s"
#~ msgstr "mount：在 %2$s 或 %3$s 中找不到 %1$s"

#~ msgid "[mntent]: warning: no final newline at the end of %s\n"
#~ msgstr "[mntent]：警告：%s 末尾没有以空行结束\n"

#~ msgid "[mntent]: line %d in %s is bad%s\n"
#~ msgstr "[mntent]：%2$s 中的第 %1$d 行有误%3$s\n"

#~ msgid "; rest of file ignored"
#~ msgstr "；文件的其余部分被忽略"

#~ msgid "umount: compiled without support for -f\n"
#~ msgstr "umount：编译时未添加 -f 支持\n"

#~ msgid "umount: cannot set group id: %m"
#~ msgstr "umount：无法设置组 id：%m"

#~ msgid "umount: cannot set user id: %m"
#~ msgstr "umount：无法设置用户 id：%m"

#~ msgid "umount: cannot fork: %s"
#~ msgstr "umount：无法 fork：%s"

#~ msgid "umount: %s: invalid block device"
#~ msgstr "umount：%s：无效的块设备"

#~ msgid "umount: %s: not mounted"
#~ msgstr "umount：%s：未挂载"

#~ msgid "umount: %s: can't write superblock"
#~ msgstr "umount：%s：无法写超级块"

#~ msgid ""
#~ "umount: %s: device is busy.\n"
#~ "        (In some cases useful info about processes that use\n"
#~ "         the device is found by lsof(8) or fuser(1))"
#~ msgstr ""
#~ "umount：%s：设备忙。\n"
#~ "        (有些情况下在 lsof(8) 或 fuser(1)) 中可以找到\n"
#~ "         有关使用该设备的进程的有用信息"

#~ msgid "umount: %s: not found"
#~ msgstr "umount：%s：未找到"

#~ msgid "umount: %s: must be superuser to umount"
#~ msgstr "umount：%s：只有超级用户才能卸载"

#~ msgid "umount: %s: block devices not permitted on fs"
#~ msgstr "umount：%s：文件系统上不允许块设备"

#~ msgid "umount: %s: %s"
#~ msgstr "umount：%s：%s"

#~ msgid "umount: internal error: invalid abs path: %s"
#~ msgstr "umount：内部错误：无效的绝对路径：%s"

#~ msgid "umount: failed to chdir to %s: %m"
#~ msgstr "umount：更改目录到 %s 失败：%m"

#~ msgid "umount: failed to obtain current directory: %m"
#~ msgstr "umount：获取当前目录失败：%m"

#~ msgid "umount: mountpoint moved (%s -> %s)"
#~ msgstr "umount：挂载点已移动(%s -> %s)"

#~ msgid "current directory moved to %s\n"
#~ msgstr "当前目录已移动到 %s\n"

#~ msgid "no umount2, trying umount...\n"
#~ msgstr "无 umount2，将尝试 umount...\n"

#~ msgid "umount: %s busy - remounted read-only\n"
#~ msgstr "umount：%s 忙 - 已重新挂载为只读\n"

#~ msgid "umount: could not remount %s read-only\n"
#~ msgstr "umount：无法以只读方式重新挂载 %s\n"

#~ msgid "%s has been unmounted\n"
#~ msgstr "%s 已经卸载\n"

#~ msgid "umount: cannot find list of filesystems to unmount"
#~ msgstr "umount：找不到要卸载的文件系统列表"

#~ msgid ""
#~ "Usage: umount -h | -V\n"
#~ "       umount -a [-d] [-f] [-r] [-n] [-v] [-t vfstypes] [-O opts]\n"
#~ "       umount [-d] [-f] [-r] [-n] [-v] special | node...\n"
#~ msgstr ""
#~ "用法：umount -h | -V\n"
#~ "       umount -a [-d] [-f] [-r] [-n] [-v] [-t 文件系统类型] [-O 选项]\n"
#~ "       umount [-d] [-f] [-r] [-n] [-v] 特殊 | 节点...\n"

#~ msgid "failed to parse 'offset=%s' options\n"
#~ msgstr "解析 'offset=%s' 选项失败\n"

#~ msgid "device %s is associated with %s\n"
#~ msgstr "设备 %s 与 %s 关联\n"

#~ msgid "Cannot unmount \"\"\n"
#~ msgstr "无法卸载 \"\"\n"

#~ msgid "umount: confused when analyzing mtab"
#~ msgstr "umount：分析 mtab 时出现混乱"

#~ msgid "umount: cannot unmount %s -- %s is mounted over it on the same point"
#~ msgstr "umount：无法卸载 %s -- %s 已在同一挂载点上挂载替换了它"

#~ msgid "Could not find %s in mtab\n"
#~ msgstr "在 mtab 中找不到 %s\n"

#~ msgid "umount: warning: %s is associated with more than one loop device\n"
#~ msgstr "umount：警告：%s 与超过一个回环设备关联\n"

#~ msgid "umount: %s is not mounted (according to mtab)"
#~ msgstr "umount：%s 未挂载(从 mtab 得知)"

#~ msgid "umount: it seems %s is mounted multiple times"
#~ msgstr "umount：似乎 %s 挂载了多次"

#~ msgid "umount: %s is not in the fstab (and you are not root)"
#~ msgstr "umount：%s 不在 fstab 中(并且您不是 root 用户)"

#~ msgid "umount: %s mount disagrees with the fstab"
#~ msgstr "umount：%s 挂载与 fstab 不一致"

#~ msgid "umount: only %s can unmount %s from %s"
#~ msgstr "umount：只有 %s 可以从 %s 上卸载 %s"

#~ msgid "umount: only root can do that"
#~ msgstr "umount：只有 root 能执行该操作"

#~ msgid ""
#~ "\n"
#~ "%1$s - sets or gets process io scheduling class and priority.\n"
#~ "\n"
#~ "Usage:\n"
#~ "  %1$s [OPTION] -p PID [PID...]\n"
#~ "  %1$s [OPTION] COMMAND\n"
#~ "\n"
#~ "Options:\n"
#~ "  -c, --class <class>   scheduling class name or number\n"
#~ "                           0: none, 1: realtime, 2: best-effort, 3: idle\n"
#~ "  -n, --classdata <num> scheduling class data\n"
#~ "                           0-7 for realtime and best-effort classes\n"
#~ "  -p, --pid=PID         view or modify already running process\n"
#~ "  -t, --ignore          ignore failures\n"
#~ "  -V, --version         output version information and exit\n"
#~ "  -h, --help            display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "%1$s - 设置或获取进程 io 调度类别和优先级。\n"
#~ "\n"
#~ "用法：\n"
#~ "  %1$s [选项] -p PID [PID...]\n"
#~ "  %1$s [选项] 命令\n"
#~ "\n"
#~ "选项：\n"
#~ "  -c, --class <类>      调度类别名或数字\n"
#~ "                           0：无，1：实时，2：尽量(best-effort)，3：空闲\n"
#~ "  -n, --classdata <数字> 调度类别数据\n"
#~ "                           0-7，针对 实时 和 尽量 调度类别\n"
#~ "  -p, --pid=PID         查看或修改已运行的进程\n"
#~ "  -t, --ignore          忽略失败\n"
#~ "  -V, --version         输出版本信息并退出\n"
#~ "  -h, --help            显示此帮助并退出\n"
#~ "\n"

#~ msgid " %s [options] <tty> [...]\n"
#~ msgstr " %s [选项] <tty> [...]\n"

#~ msgid " -s, --set-threshold <num>          set interruption threshold value\n"
#~ msgstr " -s, --set-threshold <数字>         设置中断阈值\n"

#~ msgid " -S, --set-default-threshold <num>  set default threshold value\n"
#~ msgstr " -S, --set-default-threshold <数字> 设置默认阈值\n"

#~ msgid " -t, --set-flush <num>              set flush timeout to value\n"
#~ msgstr " -t, --set-flush <数字>             设置冲刷(flush)超时值\n"

#~ msgid " -T, --set-default-flush <num>      set the default flush timeout to value\n"
#~ msgstr " -T, --set-default-flush <数字>     设置默认冲刷超时\n"

#~ msgid " -i, --interval <seconds>           gather statistics every <seconds> interval\n"
#~ msgstr " -i, --interval <秒数>              每隔这些 <秒数> 收集一次统计\n"

#~ msgid ""
#~ "File %s, For threshold value %lu, Maximum characters in fifo were %d,\n"
#~ "and the maximum transfer rate in characters/second was %f"
#~ msgstr ""
#~ "文件 %s，对应阈值 %lu，fifo 中的最大字符数为 %d，\n"
#~ "最大传输速度(字节/秒)为 %f"

#~ msgid ""
#~ "File %s, For threshold value %lu and timeout value %lu, Maximum characters in fifo were %d,\n"
#~ "and the maximum transfer rate in characters/second was %f"
#~ msgstr ""
#~ "文件 %s，对应阈值 %lu 和超时 %lu，fifo 中的最大字符数为 %d，\n"
#~ "最大传输速度(字节/秒)为 %f"

#~ msgid "cannot issue CYGETMON on %s"
#~ msgstr "无法对 %s 实施 CYGETMON 命令"

#~ msgid "cannot get threshold for %s"
#~ msgstr "无法获取 %s 的阈值"

#~ msgid "cannot get timeout for %s"
#~ msgstr "无法获取 %s 的超时"

#~ msgid "%s: %lu ints, %lu/%lu chars; fifo: %lu thresh, %lu tmout, %lu max, %lu now\n"
#~ msgstr "%s: %lu ints, %lu/%lu chars; fifo: %lu thresh, %lu tmout, %lu max, %lu now\n"

#~ msgid "   %f int/sec; %f rec, %f send (char/sec)\n"
#~ msgstr "   %f int/秒; %f rec, %f 发送 (char/秒)\n"

#~ msgid "%s: %lu ints, %lu chars; fifo: %lu thresh, %lu tmout, %lu max, %lu now\n"
#~ msgstr "%s: %lu ints, %lu chars; fifo: %lu thresh, %lu tmout, %lu max, %lu now\n"

#~ msgid "   %f int/sec; %f rec (char/sec)\n"
#~ msgstr "   %f int/秒; %f rec (char/秒)\n"

#~ msgid "Invalid interval value"
#~ msgstr "无效的间隔值"

#~ msgid "Invalid interval value: %d"
#~ msgstr "无效的间隔值：%d"

#~ msgid "Invalid set value"
#~ msgstr "无效的设置值"

#~ msgid "Invalid set value: %d"
#~ msgstr "无效的设置值：%d"

#~ msgid "Invalid default value"
#~ msgstr "无效的默认值"

#~ msgid "Invalid default value: %d"
#~ msgstr "无效的默认值：%d"

#~ msgid "Invalid set time value"
#~ msgstr "无效的设置时间值"

#~ msgid "Invalid set time value: %d"
#~ msgstr "无效的设置时间值：%d"

#~ msgid "Invalid default time value"
#~ msgstr "无效的默认时间值"

#~ msgid "Invalid default time value: %d"
#~ msgstr "无效的默认时间值：%d"

#~ msgid "cannot set %s to threshold %d"
#~ msgstr "无法将 %s 设置为阈值 %d"

#~ msgid "cannot set %s to time threshold %d"
#~ msgstr "无法将 %s 设置为时间阈值 %d"

#~ msgid "%s: %ld current threshold and %ld current timeout\n"
#~ msgstr "%s：%ld 的当前阈值和 %ld 的当前超时\n"

#~ msgid "%s: %ld default threshold and %ld default timeout\n"
#~ msgstr "%s：%ld 的默认阈值和 %ld 的默认超时\n"

#~ msgid ""
#~ " -n, --keep-size     don't modify the length of the file\n"
#~ " -p, --punch-hole    punch holes in the file\n"
#~ " -o, --offset <num>  offset of the allocation, in bytes\n"
#~ " -l, --length <num>  length of the allocation, in bytes\n"
#~ msgstr ""
#~ " -n, --keep-size     不修改文件长度\n"
#~ " -p, --punch-hole    在文件中留出空洞\n"
#~ " -o, --offset <数字>  分配的偏移(字节数)\n"
#~ " -l, --length <数字>  分配的长度(字节数)\n"

#~ msgid ""
#~ " -o, --offset <num>  offset in bytes to discard from\n"
#~ " -l, --length <num>  length of bytes to discard from the offset\n"
#~ " -m, --minimum <num> minimum extent length to discard\n"
#~ " -v, --verbose       print number of discarded bytes\n"
#~ msgstr ""
#~ " -o, --offset <数字>  要丢弃内容的起始偏移量\n"
#~ " -l, --length <数字>  从偏移量开始的丢弃长度\n"
#~ " -m, --minimum <数字> 要丢弃的最小范围长度\n"
#~ " -v, --verbose        打印丢弃字节的长度\n"

#~ msgid ""
#~ "Time elapsed since reference time has been %.6f seconds.\n"
#~ "Delaying further to reach the new time.\n"
#~ msgstr ""
#~ "时间从参考时刻起已流逝 %.6f 秒。\n"
#~ "将延迟更长时间来到达新时间。\n"

#~ msgid " -term <terminal_name>\n"
#~ msgstr " -term <终端名>\n"

#~ msgid " -reset\n"
#~ msgstr " -reset\n"

#~ msgid " -initialize\n"
#~ msgstr " -initialize\n"

#~ msgid " -cursor <on|off>\n"
#~ msgstr " -cursor <on|off>\n"

#~ msgid " -repeat <on|off>\n"
#~ msgstr " -repeat <on|off>\n"

#~ msgid " -appcursorkeys <on|off>\n"
#~ msgstr " -appcursorkeys <on|off>\n"

#~ msgid " -linewrap <on|off>\n"
#~ msgstr " -linewrap <on|off>\n"

#~ msgid " -default\n"
#~ msgstr " -default\n"

#~ msgid " -foreground <default|black|blue|cyan|green|magenta|red|white|yellow>\n"
#~ msgstr " -foreground <default|black|blue|cyan|green|magenta|red|white|yellow>\n"

#~ msgid " -background <default|black|blue|cyan|green|magenta|red|white|yellow>\n"
#~ msgstr " -background <default|black|blue|cyan|green|magenta|red|white|yellow>\n"

#~ msgid " -hbcolor <black|blue|bright|cyan|green|grey|magenta|red|white|yellow>\n"
#~ msgstr " -hbcolor <black|blue|bright|cyan|green|grey|magenta|red|white|yellow>\n"

#~ msgid " -inversescreen <on|off>\n"
#~ msgstr " -inversescreen <on|off>\n"

#~ msgid " -bold <on|off>\n"
#~ msgstr " -bold <on|off>\n"

#~ msgid " -blink <on|off>\n"
#~ msgstr " -blink <on|off>\n"

#~ msgid " -reverse <on|off>\n"
#~ msgstr " -reverse <on|off>\n"

#~ msgid " -underline <on|off>\n"
#~ msgstr " -underline <on|off>\n"

#~ msgid " -store\n"
#~ msgstr " -store\n"

#~ msgid " -clear <all|rest>\n"
#~ msgstr " -clear <all|rest>\n"

#~ msgid " -tabs <tab1 tab2 tab3 ...>      (tabn = 1-160)\n"
#~ msgstr " -tabs <tab1 tab2 tab3 ...>      (tabn = 1-160)\n"

#~ msgid " -clrtabs <tab1 tab2 tab3 ...>   (tabn = 1-160)\n"
#~ msgstr " -clrtabs <tab1 tab2 tab3 ...>   (tabn = 1-160)\n"

#~ msgid " -regtabs <1-160>\n"
#~ msgstr " -regtabs <1-160>\n"

#~ msgid " -blank <0-60|force|poke>\n"
#~ msgstr " -blank <0-60|force|poke>\n"

#~ msgid " -dump   <1-NR_CONSOLES>\n"
#~ msgstr " -dump   <1-NR_CONSOLES>\n"

#~ msgid " -append <1-NR_CONSOLES>\n"
#~ msgstr " -append <1-NR_CONSOLES>\n"

#~ msgid " -file dumpfilename\n"
#~ msgstr " -file dumpfilename\n"

#~ msgid " -msg <on|off>\n"
#~ msgstr " -msg <on|off>\n"

#~ msgid " -msglevel <0-8>\n"
#~ msgstr " -msglevel <0-8>\n"

#~ msgid " -powerdown <0-60>\n"
#~ msgstr " -powerdown <0-60>\n"

#~ msgid " -blength <0-2000>\n"
#~ msgstr " -blength <0-2000>\n"

#~ msgid " -bfreq freqnumber\n"
#~ msgstr " -bfreq freqnumber\n"

#~ msgid "Error writing screendump"
#~ msgstr "写屏幕转储失败"

#~ msgid "Couldn't read neither /dev/vcsa0 nor /dev/vcsa"
#~ msgstr "无法读 /dev/vcsa0 或 /dev/vcsa"

#~ msgid ""
#~ "Usage: %s [options] file...\n"
#~ "\n"
#~ msgstr ""
#~ "用法：%s [选项] 文件...\n"
#~ "\n"

#~ msgid ""
#~ "Options:\n"
#~ "  -d        display help instead of ring bell\n"
#~ "  -f        count logical, rather than screen lines\n"
#~ "  -l        suppress pause after form feed\n"
#~ "  -p        do not scroll, clean screen and display text\n"
#~ "  -c        do not scroll, display text and clean line ends\n"
#~ "  -u        suppress underlining\n"
#~ "  -s        squeeze multiple blank lines into one\n"
#~ "  -NUM      specify the number of lines per screenful\n"
#~ "  +NUM      display file beginning from line number NUM\n"
#~ "  +/STRING  display file beginning from search string match\n"
#~ "  -V        output version information and exit\n"
#~ msgstr ""
#~ "选项：\n"
#~ "  -d        显示帮助，而不是响铃\n"
#~ "  -f        统计逻辑行数而不是屏幕行数\n"
#~ "  -l        抑制换页(form feed)后的暂停\n"
#~ "  -p        不滚屏，清屏并显示文本\n"
#~ "  -c        不滚屏，显示文本并清理行尾\n"
#~ "  -u        抑制下划线\n"
#~ "  -s        将多个空行压缩为一行\n"
#~ "  -NUM      指定每屏显示的行数为 NUM\n"
#~ "  +NUM      从文件第 NUM 行开始显示\n"
#~ "  +/STRING  从匹配搜索字符串 STRING 的文件位置开始显示\n"
#~ "  -V        输出版本信息并退出\n"

#~ msgid "line too long"
#~ msgstr "行过长"

#~ msgid "set blocksize"
#~ msgstr "设置块大小"

#~ msgid "one bad block\n"
#~ msgstr "一个坏块\n"

#~ msgid "partition type hex or uuid"
#~ msgstr "分区类型 十六进制 或 uuid"

#~ msgid " %s [options] device\n"
#~ msgstr " %s [选项] 设备\n"

#~ msgid "read failed %s"
#~ msgstr "读失败：%s"

#~ msgid "seek failed %s"
#~ msgstr "定位失败：%s"

#~ msgid "seek failed: %d"
#~ msgstr "定位失败：%d"

#~ msgid "write failed: %d"
#~ msgstr "写失败：%d"

#~ msgid "Detected %d error(s)."
#~ msgstr "检测到 %d 个错误。"

#~ msgid "No partitions defined"
#~ msgstr "未定义分区"

#~ msgid ""
#~ " -a, --all                     list all used devices\n"
#~ " -d, --detach <loopdev> [...]  detach one or more devices\n"
#~ " -D, --detach-all              detach all used devices\n"
#~ " -f, --find                    find first unused device\n"
#~ " -c, --set-capacity <loopdev>  resize device\n"
#~ " -j, --associated <file>       list all devices associated with <file>\n"
#~ msgstr ""
#~ " -a, --all                     列出所有使用的设备\n"
#~ " -d, --detach <回环设备> [...] 断开一个或多个设备\n"
#~ " -D, --detach-all              断开所有使用的设备\n"
#~ " -f, --find                    查找第一个未使用的设备\n"
#~ " -c, --set-capacity <回环设备> 调整设备大小\n"
#~ " -j, --associated <文件>       列出所有与 <文件> 关联的设备\n"

#~ msgid "%s: failed to set up loop device, offset is not 512-byte aligned."
#~ msgstr "%s：设置回环设备失败，偏移没有对齐 512 字节。"

#~ msgid "unssuported --local-line mode argument"
#~ msgstr "不支持的 --local-line 模式参数"

#~ msgid "usage:\n"
#~ msgstr "用法:\n"

#~ msgid "\tNOTE: elvtune only works with 2.4 kernels\n"
#~ msgstr "\t注：elvtune 只能与 2.4 内核配合使用\n"

#~ msgid "missing blockdevice, use -h for help\n"
#~ msgstr "缺少块设备，请使用 -h 获取帮助\n"

#~ msgid ""
#~ "\n"
#~ "elvtune is only useful on older kernels;\n"
#~ "for 2.6 use IO scheduler sysfs tunables instead..\n"
#~ msgstr ""
#~ "\n"
#~ "elvtune 只用在旧内核上；\n"
#~ "对于 2.6 内核，请转用 IO 调度器 sysfs tunables..\n"

#~ msgid "edition number argument failed"
#~ msgstr "修订版本号 参数失败"

#~ msgid "fsync failed"
#~ msgstr "fsync 失败"

#~ msgid ""
#~ "\n"
#~ "Usage:\n"
#~ "Print version:\n"
#~ "        %s -v\n"
#~ "Print partition table:\n"
#~ "        %s -P {r|s|t} [options] device\n"
#~ "Interactive use:\n"
#~ "        %s [options] device\n"
#~ "\n"
#~ "Options:\n"
#~ "-a: Use arrow instead of highlighting;\n"
#~ "-z: Start with a zero partition table, instead of reading the pt from disk;\n"
#~ "-c C -h H -s S: Override the kernel's idea of the number of cylinders,\n"
#~ "                the number of heads and the number of sectors/track.\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "用法：\n"
#~ "打印版本：\n"
#~ "        %s -v\n"
#~ "打印分区表：\n"
#~ "        %s -P {r|s|t} [选项] 设备\n"
#~ "交互式使用：\n"
#~ "        %s [选项] 设备\n"
#~ "\n"
#~ "选项：\n"
#~ "-a：使用箭头代替高亮；\n"
#~ "-z：以空分区表启动，而非从磁盘读取分区表；\n"
#~ "-c C -h H -s S：覆盖内核检测到的柱面数、磁头数\n"
#~ "                和扇区/磁道数。\n"
#~ "\n"

#~ msgid "Writing disklabel to %s.\n"
#~ msgstr "正在将磁盘标签写入 %s。\n"

#~ msgid "Last %s or +size or +sizeM or +sizeK"
#~ msgstr "终止 %s 或 +size 或 +sizeM 或 +sizeK"

#~ msgid "Reading disklabel of %s at sector %d.\n"
#~ msgstr "从扇区 %2$d 位置读取 %1$s 的标签。\n"

#~ msgid "BSD disklabel command (m for help): "
#~ msgstr "BSD 磁盘标签命令(输入 m 获取帮助)："

#~ msgid "drivedata: "
#~ msgstr "驱动数据："

#~ msgid "#       start       end      size     fstype   [fsize bsize   cpg]\n"
#~ msgstr "#       起点        终点     大小     文件系统 [fsize bsize   cpg]\n"

#~ msgid "Must be <= sectors/track * tracks/cylinder (default).\n"
#~ msgstr "必须 <= 扇区/磁道 * 磁道/柱面 (默认)。\n"

#~ msgid "Partition (a-%c): "
#~ msgstr "分区 (a-%c)："

#~ msgid ""
#~ "\n"
#~ "Syncing disks.\n"
#~ msgstr ""
#~ "\n"
#~ "正在同步磁盘\n"

#~ msgid ""
#~ "Usage:\n"
#~ " %1$s [options] <disk>    change partition table\n"
#~ " %1$s [options] -l <disk> list partition table(s)\n"
#~ " %1$s -s <partition>      give partition size(s) in blocks\n"
#~ "\n"
#~ "Options:\n"
#~ " -b <size>             sector size (512, 1024, 2048 or 4096)\n"
#~ " -c[=<mode>]           compatible mode: 'dos' or 'nondos' (default)\n"
#~ " -h                    print this help text\n"
#~ " -u[=<unit>]           display units: 'cylinders' or 'sectors' (default)\n"
#~ " -v                    print program version\n"
#~ " -C <number>           specify the number of cylinders\n"
#~ " -H <number>           specify the number of heads\n"
#~ " -S <number>           specify the number of sectors per track\n"
#~ "\n"
#~ msgstr ""
#~ "用法：\n"
#~ " %1$s [选项] <磁盘>    更改分区表\n"
#~ " %1$s [选项] -l <磁盘> 列出分区表\n"
#~ " %1$s -s <分区>        给出分区大小(块数)\n"
#~ "\n"
#~ "选项：\n"
#~ " -b <大小>             扇区大小(512、1024、2048或4096)\n"
#~ " -c[=<模式>]           兼容模式：“dos”或“nondos”(默认)\n"
#~ " -h                    打印此帮助文本\n"
#~ " -u[=<单位>]           显示单位：“cylinders”(柱面)或“sectors”(扇区，默认)\n"
#~ " -v                    打印程序版本\n"
#~ " -C <数字>             指定柱面数\n"
#~ " -H <数字>             指定磁头数\n"
#~ " -S <数字>             指定每个磁道的扇区数\n"
#~ "\n"

#~ msgid "unable to seek on %s"
#~ msgstr "无法在 %s 上定位"

#~ msgid "unable to write %s"
#~ msgstr "不能写 %s"

#~ msgid "fatal error"
#~ msgstr "致命错误"

#~ msgid "Command action"
#~ msgstr "命令操作"

#~ msgid "You must set"
#~ msgstr "您必须设置"

#~ msgid "heads"
#~ msgstr "磁头"

#~ msgid " and "
#~ msgstr " 和 "

#~ msgid "Unsupported suffix: '%s'.\n"
#~ msgstr "不支持的后缀：“%s”。\n"

#~ msgid ""
#~ "Supported: 10^N: KB (KiloByte), MB (MegaByte), GB (GigaByte)\n"
#~ "            2^N: K  (KibiByte), M  (MebiByte), G  (GibiByte)\n"
#~ msgstr ""
#~ "支持：10^N: KB (千字节), MB (兆字节), GB (吉字节)\n"
#~ "            2^N: K  (约千字节), M  (约兆字节), G  (约吉字节)\n"

#~ msgid "Using default value %u\n"
#~ msgstr "将使用默认值 %u\n"

#~ msgid ""
#~ "\n"
#~ "Disk %s: %ld MB, %lld bytes"
#~ msgstr ""
#~ "\n"
#~ "磁盘 %s：%ld MB, %lld 字节"

#~ msgid ""
#~ "\n"
#~ "Disk %s: %ld.%ld GB, %llu bytes"
#~ msgstr ""
#~ "\n"
#~ "磁盘 %s：%ld.%ld GB, %llu 字节"

#~ msgid ", %llu sectors\n"
#~ msgstr "，%llu 个扇区\n"

#~ msgid "cannot write disk label"
#~ msgstr "无法写磁盘标签"

#~ msgid ""
#~ "\n"
#~ "Error closing file\n"
#~ msgstr ""
#~ "\n"
#~ "关闭文件出错\n"

#~ msgid "Warning: setting sector offset for DOS compatibility\n"
#~ msgstr "警告：会设置扇区偏移量以与 DOS 兼容\n"

#~ msgid "Detected an OSF/1 disklabel on %s, entering disklabel mode.\n"
#~ msgstr "在 %s 上检测到 OSF/1 磁盘标签，将进入磁盘标签模式。\n"

#~ msgid ""
#~ "\n"
#~ "WARNING: DOS-compatible mode is deprecated. It's strongly recommended to\n"
#~ "         switch off the mode (with command 'c')."
#~ msgstr ""
#~ "\n"
#~ "警告：DOS 兼容模式已废弃。强烈建议您关闭该模式(用“c”命令)。"

#~ msgid ""
#~ "\n"
#~ "WARNING: cylinders as display units are deprecated. Use command 'u' to\n"
#~ "         change units to sectors.\n"
#~ msgstr ""
#~ "\n"
#~ "警告：以柱面作为显示单位已废弃。请使用“u”命令来将单位改为扇区。\n"

#~ msgid "New disk identifier (current 0x%08x): "
#~ msgstr "新磁盘标识符(当前为 0x%08x)："

#~ msgid "No free sectors available\n"
#~ msgstr "没有空闲扇区可用\n"

#~ msgid "     phys=(%d, %d, %d) "
#~ msgstr "     物理=(%d, %d, %d) "

#~ msgid "logical=(%d, %d, %d)\n"
#~ msgstr "逻辑=(%d, %d, %d)\n"

#~ msgid "Warning: bad start-of-data in partition %zd\n"
#~ msgstr "警告：分区 %zd 数据起点有误\n"

#~ msgid "Adding a primary partition\n"
#~ msgstr "添加主分区\n"

#~ msgid ""
#~ "\n"
#~ "WARNING: If you have created or modified any DOS 6.xpartitions, please see the fdisk manual page for additionalinformation.\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "警告：如果您创建或修改了 DOS 6.x 分区，请查看 fdisk 手册页面了解其他信息。\n"
#~ "\n"

#~ msgid "%*s Boot      Start         End      Blocks   Id  System\n"
#~ msgstr "%*s 启动      起点          终点     块数   Id  系统\n"

#~ msgid "Nr AF  Hd Sec  Cyl  Hd Sec  Cyl     Start      Size ID\n"
#~ msgstr ""
#~ "序 启  磁 扇区 柱面 磁 扇区 柱面    起始       大小 ID\n"
#~ "号 动  头           头\n"

#~ msgid ""
#~ "\n"
#~ "\tThere is a valid Mac label on this disk.\n"
#~ "\tUnfortunately fdisk(1) cannot handle these disks.\n"
#~ "\tUse either pdisk or parted to modify the partition table.\n"
#~ "\tNevertheless some advice:\n"
#~ "\t1. fdisk will destroy its contents on write.\n"
#~ "\t2. Be sure that this disk is NOT a still vital\n"
#~ "\t   part of a volume group. (Otherwise you may\n"
#~ "\t   erase the other disks as well, if unmirrored.)\n"
#~ msgstr ""
#~ "\n"
#~ "\t该磁盘上有一个有效的 Mac 标签。\n"
#~ "\t很不幸，fdisk(1) 无法操作这类磁盘。\n"
#~ "\t请使用 pdisk 或 parted 来修改该分区表。\n"
#~ "\t仍然提醒您：\n"
#~ "\t1. fdisk 在写入时会破坏磁盘上的内容。\n"
#~ "\t2. 请确保该磁盘当前“不是”某个卷组(volume group)\n"
#~ "\t   的关键部分(否则您可能同时擦除组里的其他磁盘，\n"
#~ "\t   如果没有镜像备份的话。)\n"

#~ msgid ""
#~ "\tSorry - this fdisk cannot handle Mac disk labels.\n"
#~ "\tIf you want to add DOS-type partitions, create\n"
#~ "\ta new empty DOS partition table first. (Use o.)\n"
#~ "\tWARNING: This will destroy the present disk contents.\n"
#~ msgstr ""
#~ "\t抱歉，该版本的 fdisk 无法操作 Mac 磁盘标签。\n"
#~ "\t如果您想添加 DOS 类型的分区，请先创建一个空的\n"
#~ "\tDOS 分区表(使用 o 选项。)\n"
#~ "\t警告：此操作会破坏当前磁盘内容。\n"

#~ msgid "According to MIPS Computer Systems, Inc the Label must not contain more than 512 bytes\n"
#~ msgstr "根据 MIPS 计算机系统规定，增加标签长度后不能超过 512 个字节\n"

#~ msgid "ID=%02x\tSTART=%d\tLENGTH=%d\n"
#~ msgstr "ID=%02x\t起始=%d\t长度=%d\n"

#~ msgid ""
#~ "Done\n"
#~ "\n"
#~ msgstr ""
#~ "完成\n"
#~ "\n"

#~ msgid "Created partition %zd\n"
#~ msgstr "已创建分区 %zd\n"

#~ msgid " %s [options] -u <USER> COMMAND\n"
#~ msgstr " %s [选项] -u <USER> COMMAND\n"

#~ msgid " %s [options] [-] [USER [arg]...]\n"
#~ msgstr " %s [选项] [-] [USER [参数]...]\n"

#~ msgid "                                 and do not create a new session\n"
#~ msgstr "                                 而不创建新会话\n"

#~ msgid ""
#~ " -1, --one        show only current month (default)\n"
#~ " -3, --three      show previous, current and next month\n"
#~ " -s, --sunday     Sunday as first day of week\n"
#~ " -m, --monday     Monday as first day of week\n"
#~ " -j, --julian     output Julian dates\n"
#~ " -y, --year       show whole current year\n"
#~ " -V, --version    display version information and exit\n"
#~ " -h, --help       display this help text and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -1, --one        只显示当前月份(默认)\n"
#~ " -3, --three      显示上个月、当月和下个月\n"
#~ " -s, --sunday     周日作为一周第一天\n"
#~ " -m, --monday     周一用为一周第一天\n"
#~ " -j, --julian     输出儒略日\n"
#~ " -y, --year       输出整年\n"
#~ " -V, --version    显示版本信息并退出\n"
#~ " -h, --help       显示此帮助并退出\n"
#~ "\n"

#~ msgid ""
#~ " -d, --udp             use UDP only\n"
#~ " -i, --id              log the process ID too\n"
#~ " -f, --file <file>     log the contents of this file\n"
#~ " -h, --help            display this help text and exit\n"
#~ msgstr ""
#~ " -d, --udp             只使用 UDP\n"
#~ " -i, --id              同时记录进程 ID\n"
#~ " -f, --file <文件>     记录此文件的内容\n"
#~ " -h, --help            显示此帮助并退出\n"

#~ msgid ""
#~ " -n, --server <name>   write to this remote syslog server\n"
#~ " -P, --port <number>   use this UDP port\n"
#~ " -p, --priority <prio> mark given message with this priority\n"
#~ " -s, --stderr          output message to standard error as well\n"
#~ msgstr ""
#~ " -n, --server <名称>   写入此远程 syslog 服务器\n"
#~ " -P, --port <数字>     使用此 UDP 端口\n"
#~ " -p, --priority <优先级> 用此优先级标记给定的消息\n"
#~ " -s, --stderr          也将消息输出到标准错误\n"

#~ msgid ""
#~ " -t, --tag <tag>       mark every line with this tag\n"
#~ " -u, --socket <socket> write to this Unix socket\n"
#~ " -V, --version         output version information and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -t, --tag <标志>      用此标志标记每一行\n"
#~ " -u, --socket <套接字> 写入此 Unix 套接字\n"
#~ " -V, --version         输出版本信息并退出\n"
#~ "\n"

#~ msgid "Failed to open/create %s: %m\n"
#~ msgstr "打开/创建 %s 失败：%m\n"

#~ msgid "Failed to lock %s: %m\n"
#~ msgstr "锁定 %s 失败：%m\n"

#~ msgid ""
#~ " -T, --ctime                 show human readable timestamp (could be \n"
#~ "                               inaccurate if you have used SUSPEND/RESUME)\n"
#~ msgstr ""
#~ " -T, --ctime                 显示易读的时间戳(如果您使用了\n"
#~ "                                SUSPEND/RESUME 则可能不准)\n"

#~ msgid "--notime can't be used together with --ctime or --reltime"
#~ msgstr "--notime 不能与--ctime 或 --reltime 同时使用"

#~ msgid "find unused loop device failed"
#~ msgstr "查找未使用回环设备失败"

#~ msgid ""
#~ " -v, --verbose      explain what is being done\n"
#~ " -V, --version      output version information and exit\n"
#~ " -h, --help         output help screen and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -v, --verbose      解释正在进行的操作\n"
#~ " -V, --version      输出版本信息并退出\n"
#~ " -h, --help         输出帮助屏幕并退出\n"
#~ "\n"

#~ msgid ""
#~ " -n, --nobanner          do not print banner, works only for root\n"
#~ " -t, --timeout <timeout> write timeout in seconds\n"
#~ " -V, --version           output version information and exit\n"
#~ " -h, --help              display this help and exit\n"
#~ "\n"
#~ msgstr ""
#~ " -n, --nobanner          不打印标语(banner)，只对 root 有效\n"
#~ " -t, --timeout <超时>    写超时(秒数)\n"
#~ " -V, --version           输出版本信息并退出\n"
#~ " -h, --help              显示此帮助并退出\n"
#~ "\n"

#~ msgid " -o, --output-separator <string>\n"
#~ msgstr " -o, --output-separator <字符串>\n"

#~ msgid ""
#~ "\n"
#~ "Usage:\n"
#~ " %s [options] file...\n"
#~ msgstr ""
#~ "\n"
#~ "用法：\n"
#~ " %s [选项] 文件 ...\n"

#~ msgid ""
#~ "\n"
#~ "Options:\n"
#~ " -b              one-byte octal display\n"
#~ " -c              one-byte character display\n"
#~ " -C              canonical hex+ASCII display\n"
#~ " -d              two-byte decimal display\n"
#~ " -o              two-byte octal display\n"
#~ " -x              two-byte hexadecimal display\n"
#~ " -e format       format string to be used for displaying data\n"
#~ " -f format_file  file that contains format strings\n"
#~ " -n length       interpret only length bytes of input\n"
#~ " -s offset       skip offset bytes from the beginning\n"
#~ " -v              display without squeezing similar lines\n"
#~ " -V              output version information and exit\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "选项：\n"
#~ " -b              单字节八进制显示\n"
#~ " -c              单字节字符显示\n"
#~ " -C              规范化 十六进制+ASCII 显示\n"
#~ " -d              两字节十进制显示\n"
#~ " -o              两字节八进制显示\n"
#~ " -x              两字节十六进制显示\n"
#~ " -e 格式         用于显示数据的格式字符串\n"
#~ " -f 格式文件     包含格式字符串的文件\n"
#~ " -n 长度         只解释输入的指定长度个字节\n"
#~ " -s 偏移         跳过开头指定长度个字节\n"
#~ " -v              显示时不压缩相似的行\n"
#~ " -V              显示此帮助并退出\n"
#~ "\n"

#~ msgid "crypt failed: %m\n"
#~ msgstr "加密失败：%m\n"

#~ msgid "Can not fork: %m\n"
#~ msgstr "无法 fork：%m\n"

#~ msgid "bug in xstrndup call"
#~ msgstr "xstrndup 调用中有问题"
