{ LCME_FL_NOCOMPR, "nocompr" },
};
-
-/* map compression algorithm compress level to 4bits value */
-#ifndef LZ4_ACCELERATION_DEFAULT
-#define LZ4_ACCELERATION_DEFAULT 1
-#endif
-
-#ifndef LZ4HC_DEFAULT_CLEVEL
-#define LZ4HC_DEFAULT_CLEVEL 9
-
-/* Level as stored in the Lustre file layout is limited to 4 bits, i.e.
- * between 0 and 15.
- * So we map the provided level to the lz4hc compression level
- * simply by adding 1.
- */
-static inline __u8 to_lz4hc_level(__u8 level)
-{
- return level + 1;
-}
-
-#endif
-
-#ifndef LZ4HC_MIN_CLEVEL
-#define LZ4HC_MIN_CLEVEL 3
-#endif
-
-/* if user does not set level (-1), it would be set to the default level */
-static inline __u8 from_lz4hc_level(int level)
-{
- if (level == -1)
- return LZ4_ACCELERATION_DEFAULT - 1;
- if ((level - 1) > 0xf)
- return 0xf;
- return level - 1;
-}
-
-/* Level as stored in the Lustre file layout is limited to 4 bits, i.e.
- * between 0 and 15. But for lz4fast, acceleration factor can be fine tuned
- * with each successive value providing roughly +~3% to speed.
- * So we map the provided level to the lz4 acceleration factor by keeping 1-9
- * as-is, and then going by steps of 3 so 12 15 18 21 24 27.
- * And to mock lz4 command line utility behavior, the user provided factor is
- * actually applied internally as 'value + 1'.
- */
-static inline __u8 to_lz4fast_lvl(__u8 level)
-{
- if (level < 10)
- return level - 1;
- return (level - 9) * 3 + 9 - 1;
-}
-
-static inline __u8 from_lz4fast_lvl(int level)
-{
- if (level <= 0)
- return LZ4_ACCELERATION_DEFAULT + 1;
- if (level < 10)
- return level + 1;
- if ((level - 9) / 3 + 9 + 1 > 0xf)
- return 0xf;
- return (level - 9) / 3 + 9 + 1;
-}
-
-static inline __u8 from_gzip_level(int level)
-{
- if (level == -1)
- return 6;
- if (level == 0)
- return 1;
- if (level > 9)
- return 9;
- return level;
-}
-
-typedef __u8 (*from_compress_level)(int level);
-typedef __u8 (*to_compress_level)(__u8 level);
-
-static const struct compr_type_name {
- enum ll_compr_type ctn_compr_type;
- const char *ctn_name;
- from_compress_level ctn_from_compr_level;
- to_compress_level ctn_to_compr_level;
-} compr_type_table[] = {
- { LL_COMPR_TYPE_NONE, "none", NULL, NULL },
- { LL_COMPR_TYPE_FAST, "fast", NULL, NULL },
- { LL_COMPR_TYPE_BEST, "best", NULL, NULL },
- { LL_COMPR_TYPE_GZIP, "gzip", from_gzip_level, NULL },
- { LL_COMPR_TYPE_LZ4FAST, "lz4fast", from_lz4fast_lvl, to_lz4fast_lvl },
- { LL_COMPR_TYPE_LZ4HC, "lz4", from_lz4hc_level, to_lz4hc_level },
- { LL_COMPR_TYPE_LZO, "lzo", NULL, NULL },
-};
-
/* HSM component flags table */
static const struct hsm_flag_name {
enum hsm_states hfn_flag;
#include <linux/crypto.h>
#define LL_COMPR_GAP 4096
-int alloc_compr(const char *obd_name, enum ll_compr_type *type,
- unsigned int *lvl, struct crypto_comp **cc, bool decompress);
-
+int alloc_compr(struct client_obd *cli, enum ll_compr_type *type,
+ unsigned int *lvl, struct crypto_comp **cc);
+int alloc_decompr(const char *obd_name, enum ll_compr_type *type,
+ unsigned int *lvl, struct crypto_comp **cc);
int compress_chunk(const char *obd_name, struct crypto_comp *cc,
const unsigned char *in, unsigned int in_len,
unsigned char *out, unsigned int *out_len,
unsigned char *out, unsigned int *out_len,
enum ll_compr_type type, unsigned int lvl);
+int compress_str2type(char *s_type, enum ll_compr_type *type,
+ char *s_level, int *level);
+
#endif /* _LUSTRE_COMPR_H_ */
__u64 cl_quota_last_xid;
/* Links to the global list of registered changelog devices */
struct list_head cl_chg_dev_linkage;
+ enum ll_compr_type cl_compr_type_fast;
+ unsigned int cl_compr_fast_level;
+ enum ll_compr_type cl_compr_type_best;
+ unsigned int cl_compr_best_level;
};
#define obd2cli_tgt(obd) ((char *)(obd)->u.cli.cl_target_uuid.uuid)
#define QIF_ALL (QIF_LIMITS | QIF_USAGE | QIF_TIMES)
#endif
-#endif /* !__KERNEL__ */
+#endif /* NEED_QUOTA_DEFS */
/* lustre volatile file support
* file name header: ".^L^S^T^R:volatile"
#define COMPR_CHUNK_MAX_BITS 26 /* == PTLRPC_MAX_BRW_BITS */
#define COMPR_LEVEL_MAX 31
#define COMPR_MIN_PAGES (1UL << (COMPR_CHUNK_MIN_BITS - PAGE_SHIFT))
+
+/* map compression algorithm compress level to 4bits value */
+#ifndef LZ4_ACCELERATION_DEFAULT
+#define LZ4_ACCELERATION_DEFAULT 1
+#endif
+
+#ifndef LZ4HC_DEFAULT_CLEVEL
+#define LZ4HC_DEFAULT_CLEVEL 9
+
+/* Level as stored in the Lustre file layout is limited to 4 bits, i.e.
+ * between 0 and 15.
+ * So we map the provided level to the lz4hc compression level
+ * simply by adding 1.
+ */
+static inline __u8 to_lz4hc_lvl(__u8 level)
+{
+ return level + 1;
+}
+
+#endif
+
+#ifndef LZ4HC_MIN_CLEVEL
+#define LZ4HC_MIN_CLEVEL 3
+#endif
+
+/* if user does not set level (-1), it would be set to the default level */
+static inline __u8 from_lz4hc_lvl(int level)
+{
+ if (level == -1)
+ return LZ4_ACCELERATION_DEFAULT - 1;
+ if ((level - 1) > 0xf)
+ return 0xf;
+ return level - 1;
+}
+
+/* Level as stored in the Lustre file layout is limited to 4 bits, i.e.
+ * between 0 and 15. But for lz4fast, acceleration factor can be fine tuned
+ * with each successive value providing roughly +~3% to speed.
+ * So we map the provided level to the lz4 acceleration factor by keeping 1-9
+ * as-is, and then going by steps of 3 so 12 15 18 21 24 27.
+ * And to mock lz4 command line utility behavior, the user provided factor is
+ * actually applied internally as 'value + 1'.
+ */
+static inline __u8 to_lz4fast_lvl(__u8 level)
+{
+ if (level < 10)
+ return level - 1;
+ return (level - 9) * 3 + 9 - 1;
+}
+
+static inline __u8 from_lz4fast_lvl(int level)
+{
+ if (level <= 0)
+ return LZ4_ACCELERATION_DEFAULT + 1;
+ if (level < 10)
+ return level + 1;
+ if ((level - 9) / 3 + 9 + 1 > 0xf)
+ return 0xf;
+ return (level - 9) / 3 + 9 + 1;
+}
+
+static inline __u8 from_gzip_lvl(int level)
+{
+ if (level == -1)
+ return 6;
+ if (level == 0)
+ return 1;
+ if (level > 9)
+ return 9;
+ return level;
+}
+
+typedef __u8 (*from_compress_level)(int level);
+typedef __u8 (*to_compress_level)(__u8 level);
+
+static const struct compr_type_name {
+ enum ll_compr_type ctn_compr_type;
+ const char *ctn_name;
+ from_compress_level ctn_from_compr_level;
+ to_compress_level ctn_to_compr_level;
+} compr_type_table[] = {
+ { LL_COMPR_TYPE_NONE, "none", NULL, NULL },
+ { LL_COMPR_TYPE_FAST, "fast", NULL, NULL },
+ { LL_COMPR_TYPE_BEST, "best", NULL, NULL },
+ { LL_COMPR_TYPE_GZIP, "gzip", from_gzip_lvl, NULL },
+ { LL_COMPR_TYPE_LZ4FAST, "lz4fast", from_lz4fast_lvl, to_lz4fast_lvl },
+ { LL_COMPR_TYPE_LZ4HC, "lz4", from_lz4hc_lvl, to_lz4hc_lvl },
+ { LL_COMPR_TYPE_LZO, "lzo", NULL, NULL },
+ { LL_COMPR_TYPE_MAX, NULL, NULL, NULL},
+};
+
+static inline const char *compress_type_2str(__u8 compr_type)
+{
+ bool found = false;
+ int i = 0;
+
+ for (i = 0; compr_type_table[i].ctn_name != NULL; i++) {
+ if (compr_type == compr_type_table[i].ctn_compr_type) {
+ found = true;
+ break;
+ }
+ }
+ if (found)
+ return compr_type_table[i].ctn_name;
+
+ return("unknown");
+}
+
+static inline int mapback_compress_level(enum ll_compr_type type, __u8 level)
+{
+ int i;
+ bool known_type = false;
+
+ for (i = 0; compr_type_table[i].ctn_name != NULL; i++) {
+ if (compr_type_table[i].ctn_compr_type == type) {
+ known_type = true;
+ if (compr_type_table[i].ctn_to_compr_level != NULL)
+ return compr_type_table[i].ctn_to_compr_level(
+ level);
+ }
+ }
+
+ if (!known_type)
+ return 0;
+
+ return level;
+}
+
#if defined(__cplusplus)
}
#endif
INIT_LIST_HEAD(&cli->cl_chg_dev_linkage);
+ cli->cl_compr_type_fast = LL_COMPR_TYPE_LZ4FAST;
+ cli->cl_compr_fast_level = 0;
+ cli->cl_compr_type_best = LL_COMPR_TYPE_GZIP;
+ cli->cl_compr_best_level = 9;
+
if (connect_op == MDS_CONNECT) {
cli->cl_max_mod_rpcs_in_flight = cli->cl_max_rpcs_in_flight - 1;
OBD_ALLOC(cli->cl_mod_tag_bitmap,
}
}
-#define compr_type_fast LL_COMPR_TYPE_LZ4FAST
-#define compr_type_best LL_COMPR_TYPE_GZIP
-
-int alloc_compr(const char *obd_name, enum ll_compr_type *type,
- unsigned int *lvl, struct crypto_comp **cc, bool decompress)
+static int __alloc_compr(struct client_obd *cli, const char *obdname,
+ enum ll_compr_type *type, unsigned int *lvl,
+ struct crypto_comp **cc, bool decompress)
{
+ const char *obd_name;
+ enum ll_compr_type compr_type_best = LL_COMPR_TYPE_GZIP;
+ unsigned int compr_best_lvl = 9;
+ enum ll_compr_type compr_type_fast = LL_COMPR_TYPE_LZ4FAST;
+ unsigned int compr_fast_lvl = LL_LZ4FAST_MAX_LEVEL;
int ret = 0;
ENTRY;
LASSERT(ergo(decompress, *type != LL_COMPR_TYPE_BEST &&
*type != LL_COMPR_TYPE_FAST));
+ if (cli) {
+ obd_name = cli->cl_import->imp_obd->obd_name;
+ compr_type_best = cli->cl_compr_type_best;
+ compr_best_lvl = cli->cl_compr_best_level;
+ compr_type_fast = cli->cl_compr_type_fast;
+ compr_fast_lvl = cli->cl_compr_fast_level;
+ } else {
+ obd_name = obdname;
+ }
+
if (*type == LL_COMPR_TYPE_BEST) {
*type = compr_type_best;
- /* all compression types support a level 9 */
- *lvl = 9;
+ *lvl = compr_best_lvl;
} else if (*type == LL_COMPR_TYPE_FAST) {
*type = compr_type_fast;
/* lz4fast - our usual 'fast' interprets level as an
if (*type == LL_COMPR_TYPE_LZ4FAST)
*lvl = LL_LZ4FAST_MAX_LEVEL;
else
- /* all compression types support a level 0 */
- *lvl = 0;
+ *lvl = compr_fast_lvl;
}
load_crypto_module(*type);
}
RETURN(ret);
+}
+int alloc_compr(struct client_obd *cli, enum ll_compr_type *type,
+ unsigned int *lvl, struct crypto_comp **cc)
+{
+ return __alloc_compr(cli, NULL, type, lvl, cc, false);
}
EXPORT_SYMBOL(alloc_compr);
+int alloc_decompr(const char *obd_name, enum ll_compr_type *type,
+ unsigned int *lvl, struct crypto_comp **cc)
+{
+ return __alloc_compr(NULL, obd_name, type, lvl, cc, true);
+}
+EXPORT_SYMBOL(alloc_decompr);
+
/*
* The minimum delta between compressed and plain data to
* use the compressed one.
}
}
EXPORT_SYMBOL(unmerge_chunk);
+
+int compress_str2type(char *s_type, enum ll_compr_type *type,
+ char *s_level, int *level)
+{
+ bool found = false;
+ int i;
+ int rc = 0;
+
+ for (i = 0; compr_type_table[i].ctn_name != NULL; i++) {
+ if (strcmp(s_type, compr_type_table[i].ctn_name) == 0) {
+ *type = compr_type_table[i].ctn_compr_type;
+
+ if (s_level && level) {
+ rc = kstrtoint(s_level, 0, level);
+ if (rc)
+ return rc;
+
+ if (compr_type_table[i].ctn_from_compr_level)
+ *level = compr_type_table[i].
+ ctn_from_compr_level(*level);
+ }
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return -EINVAL;
+
+ return rc;
+}
+EXPORT_SYMBOL(compress_str2type);
type = llch->llch_compr_type;
lvl = llch->llch_compr_level;
hdr_size = llch->llch_header_size;
- rc = alloc_compr(obd_name, &type, &lvl, &cc, true);
+ rc = alloc_decompr(obd_name, &type, &lvl, &cc);
if (rc) {
CERROR("%s: Setup for decompression failed, type %i, lvl %d, rc = %d\n",
obd_name, type, lvl, rc);
#include <lprocfs_status.h>
#include <linux/seq_file.h>
#include <lustre_osc.h>
+#include <lustre_compr.h>
#include "osc_internal.h"
}
LUSTRE_RW_ATTR(grant_shrink);
+static int osc_compress_type_fast_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = m->private;
+ struct client_obd *cli = &obd->u.cli;
+
+ seq_printf(m, "%s:%d\n", compress_type_2str(cli->cl_compr_type_fast),
+ mapback_compress_level(cli->cl_compr_type_fast,
+ cli->cl_compr_fast_level));
+
+ return 0;
+}
+static ssize_t osc_compress_type_fast_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
+{
+ struct seq_file *seq = file->private_data;
+ struct obd_device *obd = seq->private;
+ struct client_obd *cli = &obd->u.cli;
+ char *kbuf;
+ char *end;
+ int rc = 0;
+
+ OBD_ALLOC(kbuf, count + 1);
+ if (kbuf == NULL)
+ return -ENOMEM;
+
+ if (copy_from_user(kbuf, buffer, count))
+ GOTO(out, rc = -EFAULT);
+ kbuf[count] = 0;
+
+ end = memchr(kbuf, ':', count);
+ if (end != NULL) {
+ *end = 0;
+ end++;
+ }
+
+ if (strcmp(kbuf, "none") == 0 || strcmp(kbuf, "fast") == 0 ||
+ strcmp(kbuf, "best") == 0)
+ GOTO(out, rc = -EINVAL);
+
+ rc = compress_str2type(kbuf, &cli->cl_compr_type_fast,
+ end, &cli->cl_compr_fast_level);
+
+out:
+ OBD_FREE(kbuf, count + 1);
+ return rc < 0 ? rc: count;
+}
+LPROC_SEQ_FOPS(osc_compress_type_fast);
+
+static int osc_compress_type_best_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = m->private;
+ struct client_obd *cli = &obd->u.cli;
+
+ seq_printf(m, "%s:%d\n", compress_type_2str(cli->cl_compr_type_best),
+ mapback_compress_level(cli->cl_compr_type_best,
+ cli->cl_compr_best_level));
+
+ return 0;
+}
+static ssize_t osc_compress_type_best_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
+{
+ struct seq_file *seq = file->private_data;
+ struct obd_device *obd = seq->private;
+ struct client_obd *cli = &obd->u.cli;
+ char *kbuf;
+ char *end;
+ int rc = 0;
+
+ OBD_ALLOC(kbuf, count + 1);
+ if (kbuf == NULL)
+ return -ENOMEM;
+
+ if (copy_from_user(kbuf, buffer, count))
+ GOTO(out, rc = -EFAULT);
+ kbuf[count] = 0;
+
+ end = memchr(kbuf, ':', count);
+ if (end != NULL) {
+ *end = 0;
+ end++;
+ }
+
+ if (strcmp(kbuf, "none") == 0 || strcmp(kbuf, "fast") == 0 ||
+ strcmp(kbuf, "best") == 0)
+ GOTO(out, rc = -EINVAL);
+
+ rc = compress_str2type(kbuf, &cli->cl_compr_type_best,
+ end, &cli->cl_compr_best_level);
+
+out:
+ OBD_FREE(kbuf, count + 1);
+ return rc < 0 ? rc: count;
+}
+LPROC_SEQ_FOPS(osc_compress_type_best);
+
LPROC_SEQ_FOPS_RO_TYPE(osc, connect_flags);
LPROC_SEQ_FOPS_RO_TYPE(osc, server_uuid);
LPROC_SEQ_FOPS_RO_TYPE(osc, timeouts);
.fops = &osc_pinger_recov_fops },
{ .name = "unstable_stats",
.fops = &osc_unstable_stats_fops },
+ { .name = "compress_type_fast",
+ .fops = &osc_compress_type_fast_fops },
+ { .name = "compress_type_best",
+ .fops = &osc_compress_type_best_fops },
{ NULL }
};
}
/* returns 0 on success, non-zero on failure to compress */
-int compress_request(const char *obd_name, struct obdo *oa,
+int compress_request(struct client_obd *cli, struct obdo *oa,
struct brw_page **pga, struct brw_page ***cpga,
u32 *page_count, __u64 kms)
{
+ const char *obd_name = cli->cl_import->imp_obd->obd_name;
struct cl_page *clpage;
struct crypto_comp *cc;
enum ll_compr_type type;
src_buf_bits = chunk_bits + 1;
dest_buf_bits = chunk_bits + 1;
- rc = alloc_compr(obd_name, &type, &lvl, &cc, false);
+ rc = alloc_compr(cli, &type, &lvl, &cc);
/* if we're unable to setup compression, alloc_compr prints a warning
* but we do not fail the IO - just write data uncompressed
*/
if (!cc) {
type = llch->llch_compr_type;
lvl = llch->llch_compr_level;
- rc = alloc_compr(obd_name, &type, &lvl, &cc, true);
+ rc = alloc_decompr(obd_name, &type, &lvl, &cc);
if (rc)
GOTO(out, rc);
}
#ifndef OSC_COMPRESS_H
#define OSC_COMPRESS_H
-int compress_request(const char *obd_name, struct obdo *oa,
+int compress_request(struct client_obd *cli, struct obdo *oa,
struct brw_page **pga, struct brw_page ***cpga,
u32 *page_count, __u64 kms);
chunk_size = (1 << cl_page_compr_bits(clpage));
- rc = compress_request(obd_name, oa, pga, &cpga, &page_count,
+ rc = compress_request(cli, oa, pga, &cpga, &page_count,
kms);
if (rc) {
/*
llapi_printf(LLAPI_MSG_NORMAL, "components:\n");
}
-static const char *compress_type_2str(__u8 compr_type)
-{
- bool found = false;
- int i = 0;
-
- for (i = 0; i < ARRAY_SIZE(compr_type_table); i++) {
- if (compr_type == compr_type_table[i].ctn_compr_type) {
- found = true;
- break;
- }
- }
- if (found)
- return compr_type_table[i].ctn_name;
- else
- return("unknown");
-}
-
-static int mapback_compress_level(enum ll_compr_type type, __u8 level)
-{
- int i;
- bool known_type = false;
-
- for (i = 0; i < ARRAY_SIZE(compr_type_table); i++) {
- if (compr_type_table[i].ctn_compr_type == type) {
- known_type = true;
- if (compr_type_table[i].ctn_to_compr_level != NULL)
- return compr_type_table[i].ctn_to_compr_level(
- level);
- }
- }
-
- if (!known_type)
- return 0;
-
- return level;
-}
-
static void lcme_flags2str(__u32 comp_flags)
{
bool found = false;
git://git.whamcloud.com / fs / lustre-release.git / commitdiff