聊聊lustre中的恢复机制之认知篇

struct obd_import {

	// 引用计数
	refcount_t		  imp_refcount;
	struct lustre_handle      imp_dlm_handle; /* client's ldlm export */

	// 当前活跃的连接
	struct ptlrpc_connection *imp_connection;

    // 当前活跃连接客户端RPC结构
     struct ptlrpc_client     *imp_client;
	/** List element for linking into pinger chain */
	struct list_head	  imp_pinger_chain;
	/** work struct for destruction of import */
	struct work_struct	  imp_zombie_work;

 
    // 请求已经发送但是未收到响应的列表
	struct list_head	imp_replay_list;
	// 请求发送列表  obd_import->imp_sending_list
	struct list_head	imp_sending_list;
	// delayed队列obd_import->imp_delayed_list
	struct list_head	imp_delayed_list;

	struct list_head	imp_committed_list;
	struct list_head	*imp_replay_cursor;
	/** @} */

	/** List of not replied requests */
	struct list_head	imp_unreplied_list;
	/** Known maximal replied XID */
	__u64			imp_known_replied_xid;

	/** obd device for this import */
	struct obd_device	*imp_obd;


	struct ptlrpc_sec        *imp_sec;
	rwlock_t		  imp_sec_lock;
	time64_t		imp_sec_expire;
	pid_t			  imp_sec_refpid;
        /** @} */

	/** Wait queue for those who need to wait for recovery completion */
	wait_queue_head_t         imp_recovery_waitq;

	/** Number of requests allocated */
	atomic_t                  imp_reqs;
	
};

enum lustre_imp_state {
		// 连接关闭
        LUSTRE_IMP_CLOSED     = 1,
        // 请求发送到服务端开启新的连接
        LUSTRE_IMP_NEW        = 2,
        // 断开连接
        LUSTRE_IMP_DISCON     = 3,
        // 连接中的状态
        LUSTRE_IMP_CONNECTING = 4,
        // 连接的响应状态
        LUSTRE_IMP_REPLAY     = 5,
        // repay & lock的连接状态
        LUSTRE_IMP_REPLAY_LOCKS = 6,
        // 响应等待的状态
        LUSTRE_IMP_REPLAY_WAIT  = 7,
        // 连接的recovery的状态
        LUSTRE_IMP_RECOVER    = 8,
        // 活跃连接的状态
        LUSTRE_IMP_FULL       = 9,
        // 被驱逐链接的状态
        LUSTRE_IMP_EVICTED    = 10,
	LUSTRE_IMP_IDLE	      = 11,
	LUSTRE_IMP_LAST
};

// 状态到名称状态转换
static inline const char *ptlrpc_import_state_name(enum lustre_imp_state state)
{
	static const char * const import_state_names[] = {
		"<UNKNOWN>", "CLOSED",  "NEW", "DISCONN",
		"CONNECTING", "REPLAY", "REPLAY_LOCKS", "REPLAY_WAIT",
		"RECOVER", "FULL", "EVICTED", "IDLE",
	};

	LASSERT(state < LUSTRE_IMP_LAST);
	return import_state_names[state];
}

static DECLARE_DELAYED_WORK(ping_work, ptlrpc_pinger_main);

void ptlrpc_fail_import(struct obd_import *imp, __u32 conn_cnt)
{
	// 设置连接断开状态
	if (ptlrpc_set_import_discon(imp, conn_cnt, true))
		ptlrpc_pinger_force(imp);

	EXIT;
}

int ptlrpc_recover_import(struct obd_import *imp...)
{
	// 强制断开连接
	ptlrpc_set_import_discon(imp, 0, false)
	rc = ptlrpc_connect_import(imp)
	{
		ptlrpc_connect_import_locked(imp)
		{
			// 尝试连接
			obd_reconnect(NULL, imp->imp_obd->obd_self_export, obd,
			   &obd->obd_uuid, &ocd, NULL)
			
		}
	}
}

int ptlrpc_reconnect_import(struct obd_import *imp)
{
	// 设置连接状态
	ptlrpc_set_import_discon(imp, 0, false)

	// 校验import
	ptlrpc_invalidate_import(imp)
	// 断开连接
	ptlrpc_disconnect_import(imp, 1)
	// 激活import发送端
	ptlrpc_activate_import(imp, false)
	// 恢复import发送端
	ptlrpc_recover_import(imp, NULL, 0);
}

int ptlrpc_resend(struct obd_import *imp)
{
	list_for_each_entry(req, &imp->imp_sending_list, rq_list) {
		if (!ptlrpc_no_resend(req) &&
		    (req->rq_timedout || !req->rq_allow_replay))
			ptlrpc_resend_req(req);
	}
}

void ptlrpc_wake_delayed(struct obd_import *imp)
{
	struct ptlrpc_request *req;

	spin_lock(&imp->imp_lock);
	list_for_each_entry(req, &imp->imp_delayed_list, rq_list) {
		ptlrpc_client_wake_req(req);
	}
	spin_unlock(&imp->imp_lock);
}