gluster 3.4.5参数及默认值

1 参数及默认值

$gluster-option

                                OPTION: DEFAULT_VALUE

           diagnostics.brick-log-level: INFO

               network.tcp-window-size: (null)

        performance.least-prio-threads: 1

               performance.open-behind: on

     performance.enable-least-priority: on

                    nfs.export-volumes: (null)

              cluster.self-heal-daemon: off

                     nfs.trusted-write: (null)

             nfs.register-with-portmap: (null)

        cluster.self-heal-readdir-size: 1KB

               cluster.rebalance-stats: off

       performance.normal-prio-threads: 16

                performance.quick-read: on

                   nfs.addr-namelookup: (null)

                     storage.owner-gid: -1

                    server.root-squash: off

     performance.read-ahead-page-count: 4

                 network.frame-timeout: 1800

                 server.statedump-path: /var/run/gluster

      cluster.data-self-heal-algorithm: (null)

                    features.lock-heal: off

                              nfs.port: (null)

                cluster.read-subvolume: (null)

       diagnostics.latency-measurement: off

                       nfs.export-dirs: (null)

               cluster.lookup-unhashed: on

  performance.write-behind-window-size: 1MB

         performance.client-io-threads: off

                  network.ping-timeout: 42

       diagnostics.brick-sys-log-level: CRITICAL

                   nfs.rpc-auth-reject: (null)

                    network.remote-dio: disable

                            auth.allow: (null)

                   cluster.quorum-type: none

       performance.cache-min-file-size: 0

          cluster.read-subvolume-index: -1

               cluster.min-free-inodes: 5%

                features.grace-timeout: (null)

                        nfs.export-dir: (null)

              cluster.readdir-failover: on

                     nfs.volume-access: (null)

              performance.write-behind: on

           performance.io-thread-count: 16

                           nfs.disable: (null)

                cluster.read-hash-mode: 0

    cluster.background-self-heal-count: 16

                    nfs.transport-type: tcp

                cluster.data-self-heal: on

      diagnostics.client-sys-log-level: CRITICAL

                     nfs.rpc-auth-null: (null)

                performance.read-ahead: on

                               nfs.nlm: (null)

                         nfs.mount-udp: (null)

       performance.cache-max-file-size: 0

         performance.high-prio-threads: 16

            performance.force-readdirp: true

         cluster.self-heal-window-size: 1

                           auth.reject: (null)

               cluster.data-change-log: on

               cluster.stripe-coalesce: false

                features.quota-timeout: 0

          performance.low-prio-threads: 16

                 performance.lazy-open: yes

             performance.stat-prefetch: on

          diagnostics.client-log-level: INFO

              cluster.readdir-optimize: off

              cluster.entry-change-log: on

     performance.strict-write-ordering: off

                 cluster.min-free-disk: 10%

            cluster.server-quorum-type: (null)

                        nfs.mem-factor: (null)

                  cluster.quorum-count: (null)

                  cluster.heal-timeout: 600

                      nfs.enable-ino32: (null)

          performance.md-cache-timeout: 1

                     storage.linux-aio: off

           performance.strict-o-direct: off

                    nfs.ports-insecure: (null)

                     nfs.rpc-auth-unix: (null)

                    nfs.rpc-auth-allow: (null)

                  cluster.choose-local: true

             cluster.stripe-block-size: 128KB

             diagnostics.dump-fd-stats: off

               network.inode-lru-limit: 16384

            performance.cache-priority:

          performance.least-rate-limit: 0

                      nfs.trusted-sync: (null)

         cluster.subvols-per-directory: (null)

                performance.cache-size: 128MB

                    cluster.eager-lock: on

                   nfs.dynamic-volumes: (null)

                  performance.io-cache: on

           cluster.metadata-change-log: on

                     storage.owner-uid: -1

     performance.cache-refresh-timeout: 1

           cluster.server-quorum-ratio: (null)

               cluster.entry-self-heal: on

            cluster.metadata-self-heal: on

              performance.flush-behind: on

2 源代码中提取的参数 

/* DHT xlator options */

{ .key        = "cluster.lookup-unhashed",

{ .key        = "cluster.min-free-disk",

{ .key        = "cluster.min-free-inodes",

{ .key        = "cluster.rebalance-stats",

{ .key        = "cluster.subvols-per-directory",

{ .key        = "cluster.readdir-optimize",

{ .key        = "cluster.nufa",

/* AFR xlator options */

{ .key        = "cluster.entry-change-log",

{ .key        = "cluster.read-subvolume",

{ .key        = "cluster.read-subvolume-index",

{ .key        = "cluster.read-hash-mode",

{ .key        = "cluster.background-self-heal-count",

{ .key        = "cluster.metadata-self-heal",

{ .key        = "cluster.data-self-heal",

{ .key        = "cluster.entry-self-heal",

{ .key        = "cluster.self-heal-daemon",

{ .key        = "cluster.heal-timeout",

{ .key        = "cluster.strict-readdir",

{ .key        = "cluster.self-heal-window-size",

{ .key        = "cluster.data-change-log",

{ .key        = "cluster.metadata-change-log",

{ .key        = "cluster.data-self-heal-algorithm",

{ .key        = "cluster.eager-lock",

{ .key        = "cluster.quorum-type",

{ .key        = "cluster.quorum-count",

{ .key        = "cluster.choose-local",

{ .key        = "cluster.self-heal-readdir-size",

{ .key        = "cluster.post-op-delay-secs",

{ .key        = "cluster.readdir-failover",

/* Stripe xlator options */

{ .key        = "cluster.stripe-block-size",

{ .key        = "cluster.stripe-coalesce",

/* IO-stats xlator options */

{ .key         = VKEY_DIAG_LAT_MEASUREMENT,

{ .key         = "diagnostics.dump-fd-stats",

{ .key         = VKEY_DIAG_CNT_FOP_HITS,

{ .key         = "diagnostics.brick-log-level",

{ .key         = "diagnostics.client-log-level",

{ .key         = "diagnostics.brick-sys-log-level",

{ .key         = "diagnostics.client-sys-log-level",

/* IO-cache xlator options */

{ .key         = "performance.cache-max-file-size",

{ .key         = "performance.cache-min-file-size",

{ .key         = "performance.cache-refresh-timeout",

{ .key         = "performance.cache-priority",

{ .key         = "performance.cache-size",

/* IO-threads xlator options */

{ .key         = "performance.io-thread-count",

{ .key         = "performance.high-prio-threads",

{ .key         = "performance.normal-prio-threads",

{ .key         = "performance.low-prio-threads",

{ .key         = "performance.least-prio-threads",

{ .key         = "performance.enable-least-priority",

{ .key         = "performance.least-rate-limit",

/* Other perf xlators‘ options */

{ .key         = "performance.cache-size",

{ .key         = "performance.flush-behind",

{ .key         = "performance.write-behind-window-size",

{ .key         = "performance.strict-o-direct",

{ .key         = "performance.strict-write-ordering",

{ .key         = "performance.read-ahead-page-count",

{ .key         = "performance.md-cache-timeout",

{ .key         = "performance.lazy-open",

/* Client xlator options */

{ .key         = "network.frame-timeout",

{ .key         = "network.ping-timeout",

{ .key         = "network.tcp-window-size",

{ .key         = "features.lock-heal",

{ .key         = "features.grace-timeout",

{ .key         = "client.ssl",

{ .key         = "network.remote-dio",

/* Server xlator options */

{ .key         = "network.tcp-window-size",

{ .key         = "network.inode-lru-limit",

{ .key         = AUTH_ALLOW_MAP_KEY,

{ .key         = AUTH_REJECT_MAP_KEY,

{ .key         = "transport.keepalive",

{ .key         = "server.allow-insecure",

{ .key         = "server.root-squash",

{ .key         = "server.statedump-path",

{ .key         = "features.lock-heal",

{ .key         = "features.grace-timeout",

{ .key         = "server.ssl",

/* Performance xlators enable/disbable options */

{ .key         = "performance.write-behind",

{ .key         = "performance.read-ahead",

{ .key         = "performance.io-cache",

{ .key         = "performance.quick-read",

{ .key         = "performance.open-behind",

{ .key         = "performance.stat-prefetch",

{ .key         = "performance.client-io-threads",

{ .key         = "performance.nfs.write-behind",

{ .key         = "performance.nfs.read-ahead",

{ .key         = "performance.nfs.io-cache",

{ .key         = "performance.nfs.quick-read",

{ .key         = "performance.nfs.stat-prefetch",

{ .key         = "performance.nfs.io-threads",

{ .key         = "performance.force-readdirp",

/* Quota xlator options */

{ .key         = VKEY_FEATURES_LIMIT_USAGE,

{ .key         = "features.quota-timeout",

/* Marker xlator options */

{ .key         = VKEY_MARKER_XTIME,

{ .key         = VKEY_MARKER_XTIME,

{ .key         = VKEY_FEATURES_QUOTA,

/* Debug xlators options */

{ .key         = "debug.trace",

{ .key         = "debug.log-history",

{ .key         = "debug.log-file",

{ .key         = "debug.exclude-ops",

{ .key         = "debug.include-ops",

{ .key         = "debug.error-gen",

/* NFS xlator options */

{ .key         = "nfs.enable-ino32",

{ .key         = "nfs.mem-factor",

{ .key         = "nfs.export-dirs",

{ .key         = "nfs.export-volumes",

{ .key         = "nfs.addr-namelookup",

{ .key         = "nfs.dynamic-volumes",

{ .key         = "nfs.register-with-portmap",

{ .key         = "nfs.port",

{ .key         = "nfs.rpc-auth-unix",

{ .key         = "nfs.rpc-auth-null",

{ .key         = "nfs.rpc-auth-allow",

{ .key         = "nfs.rpc-auth-reject",

{ .key         = "nfs.ports-insecure",

{ .key         = "nfs.transport-type",

{ .key         = "nfs.trusted-sync",

{ .key         = "nfs.trusted-write",

{ .key         = "nfs.volume-access",

{ .key         = "nfs.export-dir",

{ .key         = NFS_DISABLE_MAP_KEY,

{ .key         = "nfs.nlm",

{ .key         = "nfs.mount-udp",

{ .key         = "nfs.server-aux-gids",

/* Other options which don‘t fit any place above */

{ .key         = "features.read-only",

{ .key         = "features.worm",

{ .key         = "storage.linux-aio",

{ .key         = "storage.owner-uid",

{ .key         = "storage.owner-gid",

{ .key         = "config.memory-accounting",

{ .key         = "config.transport",

{ .key         = GLUSTERD_QUORUM_TYPE_KEY,

{ .key         = GLUSTERD_QUORUM_RATIO_KEY,

{ .key         = NULL

时间: 2024-10-08 07:24:51

gluster 3.4.5参数及默认值的相关文章

?Swift语言中为外部参数设置默认值,可变参数,常量参数,变量参数,输入输出参数

引用自这里:Swift语言中为外部参数设置默认值可变参数常量参数变量参数输入输出参数 目录[-] 7.4.4  为外部参数设置默认值 7.4.5  可变参数 7.4.6  常量参数和变量参数 7.4.7  输入-输出参数 7.4.4  为外部参数设置默认值 开发者也可以对外部参数设置默认值.这时,调用的时候,也可以省略参数传递本文选自Swift1.2语言快速入门v2.0. [示例7-11]以下的代码就为外部参数toString.withJoiner设置了默认的参数"Swift"和&qu

(转)js函数参数设置默认值

原文:http://www.cnblogs.com/RightDear/archive/2013/06/26/3156652.html js函数参数设置默认值 php有个很方便的用法是在定义函数时可以直接给参数设默认值,如: function simue ($a=1,$b=2){   return $a+$b; } echo simue(); //输出3 echo simue(10); //输出12 echo simue(10,20); //输出30 但js却不能这么定义,如果写function

js 的函数参数的默认值问题

js函数参数设置默认值 php有个很方便的用法是在定义函数时可以直接给参数设默认值,如: function simue ($a=1,$b=2){ return $a+$b; } echo simue(); //输出3 echo simue(10); //输出12 echo simue(10,20); //输出30 但js却不能这么定义,如果写function simue(a=1,b=2){}会提示缺少对象. js函数中有个储存参数的数组arguments ,所有函数获得的参数会被编译器挨个保存到

常量不加引号报错提示‘参数**没有默认值’

问:sql语句中常量不加引号报错提示'参数**没有默认值': 解决方法: 如下图所示加上英文状态下的引号:  字符串 要加上 单引号:''单引号 算一个 : 问:为何选中这列不需要加引号就能执行呢? 答: 选中那列 并非是 字符串列:数值列 不需要加 :

?Swift语言中为外部参数设置默认值可变参数常量参数变量参数输入输出参数

Swift语言中为外部参数设置默认值可变参数常量参数变量参数输入输出参数 7.4.4  为外部参数设置默认值 开发者也可以对外部参数设置默认值.这时,调用的时候,也可以省略参数传递本文选自Swift1.2语言快速入门v2.0. [示例7-11]以下的代码就为外部参数toString.withJoiner设置了默认的参数"Swift"和"---".代码如下: import Foundation func join(string s1: String, toString

ES6 函数参数的默认值

基本用法 在ES6之前,不能直接为函数的参数指定默认值,只能采取变通的方法. function log(x,y){ y = y||'world'; console.log(x,y); } log('kkk');//kkk world 这种写法的缺点在于: 如果参数y赋值了,但是对应的布尔值为false,则该赋值不起作用.如果在调用函数的时候,传入的y参数是一个空字符串,那么y就会被修改为默认值. 避免这个问题,需要先判断一下:1.通过判断值是否等于undefined,2.判断arguments.

不要使用可变类型作为参数的默认值

class HauntedBus: """备受幽灵乘客折磨的校车""" def __init__(self, passengers=[]): ? self.passengers = passengers ? def pick(self, name): self.passengers.append(name) ? def drop(self, name): self.passengers.remove(name) ? 如果没传入 passenger

php与js中函数参数的默认值设置

php函数参数默认值设置: <?phpfunction test($val=3){   echo $val."<br/>";}test(11);test();?> javascript函数参数默认值设置function test(){alert("test函数");} function test2(val,func){ val=val||"";//利用js中的或操作,第一个参数值为false(为空)时返回第二个参数的值.第

类模板参数带默认值

类模板参数可以带默认值吗?答案当然是肯定的.看过STL源码的人就知道,STL里面大量使用了模板技术. 有兴趣的可以去看看STL的源码,从中可以学到不少知识. 今天,我就写一个带默认值的类模板,如下: #pragma once template<typename T, typename T defValue = NULL> class CType { public: CType() :m_value(defValue) { } ~CType() { } BOOL IsNull() const {