linux/net/ceph/ceph_common.c

// SPDX-License-Identifier: GPL-2.0-only

#include <linux/ceph/ceph_debug.h>
#include <linux/backing-dev.h>
#include <linux/ctype.h>
#include <linux/fs.h>
#include <linux/inet.h>
#include <linux/in6.h>
#include <linux/key.h>
#include <keys/ceph-type.h>
#include <linux/module.h>
#include <linux/mount.h>
#include <linux/nsproxy.h>
#include <linux/fs_parser.h>
#include <linux/sched.h>
#include <linux/sched/mm.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/statfs.h>
#include <linux/string.h>
#include <linux/vmalloc.h>


#include <linux/ceph/ceph_features.h>
#include <linux/ceph/libceph.h>
#include <linux/ceph/debugfs.h>
#include <linux/ceph/decode.h>
#include <linux/ceph/mon_client.h>
#include <linux/ceph/auth.h>
#include "crypto.h"


/*
 * Module compatibility interface.  For now it doesn't do anything,
 * but its existence signals a certain level of functionality.
 *
 * The data buffer is used to pass information both to and from
 * libceph.  The return value indicates whether libceph determines
 * it is compatible with the caller (from another kernel module),
 * given the provided data.
 *
 * The data pointer can be null.
 */
bool libceph_compatible(void *data)
{ … }
EXPORT_SYMBOL(…);

static int param_get_supported_features(char *buffer,
					const struct kernel_param *kp)
{ … }
static const struct kernel_param_ops param_ops_supported_features = …;
module_param_cb(…);

const char *ceph_msg_type_name(int type)
{ … }
EXPORT_SYMBOL(…);

/*
 * Initially learn our fsid, or verify an fsid matches.
 */
int ceph_check_fsid(struct ceph_client *client, struct ceph_fsid *fsid)
{ … }
EXPORT_SYMBOL(…);

static int strcmp_null(const char *s1, const char *s2)
{ … }

int ceph_compare_options(struct ceph_options *new_opt,
			 struct ceph_client *client)
{ … }
EXPORT_SYMBOL(…);

int ceph_parse_fsid(const char *str, struct ceph_fsid *fsid)
{ … }
EXPORT_SYMBOL(…);

/*
 * ceph options
 */
enum { … };

enum { … };

static const struct constant_table ceph_param_read_from_replica[] = …;

enum ceph_ms_mode { … };

static const struct constant_table ceph_param_ms_mode[] = …;

static const struct fs_parameter_spec ceph_parameters[] = …;

struct ceph_options *ceph_alloc_options(void)
{ … }
EXPORT_SYMBOL(…);

void ceph_destroy_options(struct ceph_options *opt)
{ … }
EXPORT_SYMBOL(…);

/* get secret from key store */
static int get_secret(struct ceph_crypto_key *dst, const char *name,
		      struct p_log *log)
{ … }

int ceph_parse_mon_ips(const char *buf, size_t len, struct ceph_options *opt,
		       struct fc_log *l, char delim)
{ … }
EXPORT_SYMBOL(…);

int ceph_parse_param(struct fs_parameter *param, struct ceph_options *opt,
		     struct fc_log *l)
{ … }
EXPORT_SYMBOL(…);

int ceph_print_client_options(struct seq_file *m, struct ceph_client *client,
			      bool show_all)
{ … }
EXPORT_SYMBOL(…);

struct ceph_entity_addr *ceph_client_addr(struct ceph_client *client)
{ … }
EXPORT_SYMBOL(…);

u64 ceph_client_gid(struct ceph_client *client)
{ … }
EXPORT_SYMBOL(…);

/*
 * create a fresh client instance
 */
struct ceph_client *ceph_create_client(struct ceph_options *opt, void *private)
{ … }
EXPORT_SYMBOL(…);

void ceph_destroy_client(struct ceph_client *client)
{ … }
EXPORT_SYMBOL(…);

void ceph_reset_client_addr(struct ceph_client *client)
{ … }
EXPORT_SYMBOL(…);

/*
 * true if we have the mon map (and have thus joined the cluster)
 */
static bool have_mon_and_osd_map(struct ceph_client *client)
{ … }

/*
 * mount: join the ceph cluster, and open root directory.
 */
int __ceph_open_session(struct ceph_client *client, unsigned long started)
{ … }
EXPORT_SYMBOL(…);

int ceph_open_session(struct ceph_client *client)
{ … }
EXPORT_SYMBOL(…);

int ceph_wait_for_latest_osdmap(struct ceph_client *client,
				unsigned long timeout)
{ … }
EXPORT_SYMBOL(…);

static int __init init_ceph_lib(void)
{ … }

static void __exit exit_ceph_lib(void)
{ … }

module_init(…) …;
module_exit(exit_ceph_lib);

MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;