Lines Matching defs:conn
67 struct hmdfs_peer *conn;
102 struct hmdfs_peer *conn;
143 struct hmdfs_peer *conn;
276 struct hmdfs_peer *conn = info->conn;
295 conn->owner, conn->device_id,
308 conn->owner, conn->device_id, info->remote_ino,
318 conn->owner, conn->device_id, info->remote_ino,
327 static void hmdfs_wait_remote_writeback_once(struct hmdfs_peer *conn,
343 conn->owner, conn->device_id, info->remote_ino);
349 static void hmdfs_reset_remote_write_err(struct hmdfs_peer *conn,
363 conn->owner, conn->device_id, info->remote_ino,
387 static int hmdfs_flush_stash_file_data(struct hmdfs_peer *conn,
402 hmdfs_reset_remote_write_err(conn, info);
413 hmdfs_wait_remote_writeback_once(conn, info);
416 hmdfs_reset_remote_write_err(conn, info);
429 conn->owner, conn->device_id,
437 conn->owner, conn->device_id, info->remote_ino,
448 err = hmdfs_flush_stash_file_data(info->conn, info);
513 static int hmdfs_close_stash_file(struct hmdfs_peer *conn,
523 conn->owner, conn->device_id, info->remote_ino,
549 hmdfs_new_file_cache(struct hmdfs_peer *conn, struct hmdfs_inode_info *info)
577 conn->owner, conn->device_id,
584 conn->owner, conn->device_id, info->remote_ino);
595 cache->cache_file = hmdfs_new_stash_file(&conn->sbi->stash_work_dir,
596 conn->cid);
611 static void hmdfs_init_stash_file_cache(struct hmdfs_peer *conn,
616 cache = hmdfs_new_file_cache(conn, info);
658 struct hmdfs_peer *conn = info->conn;
663 conn->owner, conn->device_id, info->remote_ino);
667 err = hmdfs_close_stash_file(conn, info);
688 static void hmdfs_init_cache_for_stash_files(struct hmdfs_peer *conn,
695 old_cred = hmdfs_override_creds(conn->sbi->cred);
697 hmdfs_init_stash_file_cache(conn, info);
706 hmdfs_init_cache_for_stash_files(work->conn, work->list);
710 static void hmdfs_init_cache_for_stash_files_by_work(struct hmdfs_peer *conn,
714 .conn = conn,
724 static void hmdfs_stash_fetch_ready_files(struct hmdfs_peer *conn,
729 spin_lock(&conn->wr_opened_inode_lock);
730 list_for_each_entry(info, &conn->wr_opened_inode_list, wr_opened_node) {
741 hmdfs_remote_add_wr_opened_inode_nolock(conn, info);
746 conn->owner, conn->device_id,
750 spin_unlock(&conn->wr_opened_inode_lock);
753 static void hmdfs_stash_offline_prepare(struct hmdfs_peer *conn, int evt,
758 if (!hmdfs_is_stash_enabled(conn->sbi))
761 mutex_lock(&conn->offline_cb_lock);
763 hmdfs_stash_fetch_ready_files(conn, true, &preparing);
768 hmdfs_init_cache_for_stash_files_by_work(conn, &preparing);
770 mutex_unlock(&conn->offline_cb_lock);
773 static void hmdfs_track_inode_locked(struct hmdfs_peer *conn,
776 spin_lock(&conn->stashed_inode_lock);
777 list_add_tail(&info->stash_node, &conn->stashed_inode_list);
778 conn->stashed_inode_nr++;
779 spin_unlock(&conn->stashed_inode_lock);
796 static void hmdfs_stash_remote_inodes(struct hmdfs_peer *conn,
805 old_cred = hmdfs_override_creds(conn->sbi->cred);
815 hmdfs_track_inode_locked(conn, info);
817 hmdfs_remote_del_wr_opened_inode(conn, info);
823 hmdfs_update_peer_stash_stats(&conn->stats.stash, &stats);
825 conn->owner, conn->device_id, conn->stashed_inode_nr,
829 static void hmdfs_stash_offline_do_stash(struct hmdfs_peer *conn, int evt,
836 if (!hmdfs_is_stash_enabled(conn->sbi))
840 mutex_unlock(&conn->seq_lock);
842 mutex_lock(&conn->offline_cb_lock);
844 hmdfs_stash_fetch_ready_files(conn, false, &preparing);
846 hmdfs_init_cache_for_stash_files(conn, &preparing);
848 spin_lock(&conn->wr_opened_inode_lock);
849 list_for_each_entry(info, &conn->wr_opened_inode_list, wr_opened_node) {
855 spin_unlock(&conn->wr_opened_inode_lock);
860 hmdfs_stash_remote_inodes(conn, &stashing);
863 mutex_unlock(&conn->offline_cb_lock);
864 mutex_lock(&conn->seq_lock);
868 hmdfs_lookup_stash_inode(struct hmdfs_peer *conn, uint64_t inum)
872 list_for_each_entry(info, &conn->stashed_inode_list, stash_node) {
880 static void hmdfs_untrack_stashed_inode(struct hmdfs_peer *conn,
886 conn->stashed_inode_nr--;
889 static void hmdfs_reset_stashed_inode(struct hmdfs_peer *conn,
899 hmdfs_untrack_stashed_inode(conn, info);
910 static void hmdfs_drop_stashed_inodes(struct hmdfs_peer *conn)
915 if (list_empty(&conn->stashed_inode_list))
919 conn->owner, conn->device_id, conn->stashed_inode_nr);
922 &conn->stashed_inode_list, stash_node) {
924 conn->owner, conn->device_id, info->remote_ino,
927 hmdfs_reset_stashed_inode(conn, info);
1071 static inline bool hmdfs_is_node_offlined(const struct hmdfs_peer *conn,
1081 return hmdfs_node_evt_seq(conn) != seq;
1088 struct hmdfs_peer *conn = ctx->conn;
1096 conn->owner, conn->device_id, ctx->inum,
1108 conn->owner, conn->device_id, ctx->inum,
1116 conn->owner, conn->device_id, ctx->inum,
1126 conn->owner, conn->device_id, ctx->inum,
1136 conn->owner, conn->device_id, ctx->inum,
1144 conn->owner, conn->device_id, ctx->inum,
1153 conn->owner, conn->device_id, ctx->inum,
1161 conn->owner, conn->device_id, ctx->inum,
1173 struct hmdfs_peer *conn = ctx->conn;
1189 conn->owner, conn->device_id, ctx->inum, err);
1197 conn->owner, conn->device_id, ctx->inum,
1209 conn->owner, conn->device_id, ctx->inum, err);
1227 conn->owner, conn->device_id, ctx->inum, err);
1233 conn->owner, conn->device_id, ctx->inum);
1245 struct hmdfs_peer *conn = ctx->conn;
1259 if (hmdfs_is_node_offlined(conn, ctx->seq))
1283 ctx->conn->owner, ctx->conn->device_id, ctx->inum);
1285 opened->conn ? opened->conn->owner : 0,
1286 opened->conn ? opened->conn->device_id : 0,
1290 pinned->conn->owner, pinned->conn->device_id,
1308 static ssize_t hmdfs_write_dst(struct hmdfs_peer *conn, struct file *filp,
1334 conn->owner, conn->device_id, info->remote_ino,
1342 static int hmdfs_rd_src_wr_dst(struct hmdfs_peer *conn,
1359 conn->owner, conn->device_id, args->inum, err);
1366 err = hmdfs_write_dst(conn, args->dst, args->buf, rd, ctx->dst_pos);
1369 else if (hmdfs_is_node_offlined(conn, args->seq))
1375 static int hmdfs_copy_src_to_dst(struct hmdfs_peer *conn,
1402 conn->owner, conn->device_id,
1408 conn->owner, conn->device_id,
1415 conn->owner, conn->device_id, args->inum, data_pos);
1419 err = hmdfs_rd_src_wr_dst(conn, &ctx);
1439 err = hmdfs_copy_src_to_dst(ctx->conn, &args);
1446 if (hmdfs_is_node_offlined(ctx->conn, ctx->seq))
1463 struct hmdfs_peer *conn = ctx->conn;
1471 conn->owner, conn->device_id, inum);
1473 pinned_info = hmdfs_lookup_stash_inode(conn, inum);
1479 conn->owner, conn->device_id, inum, status);
1485 conn->owner, conn->device_id, inum);
1508 hmdfs_reset_stashed_inode(conn, pinned_info);
1512 conn->owner, conn->device_id, inum, err, ctx->keep);
1517 static int hmdfs_init_file_restore_ctx(struct hmdfs_peer *conn,
1521 struct hmdfs_sb_info *sbi = conn->sbi;
1544 ctx->conn = conn;
1623 static int hmdfs_restore_files(struct hmdfs_peer *conn,
1633 err = hmdfs_init_file_restore_ctx(conn, seq, dir, &ctx);
1680 static int hmdfs_rebuild_stash_list(struct hmdfs_peer *conn,
1691 err = hmdfs_init_file_restore_ctx(conn, seq, dir, &ctx);
1731 conn->owner, conn->device_id, ctx.inum,
1746 static int hmdfs_iter_stash_file(struct hmdfs_peer *conn,
1776 err = op(conn, seq, &dir, tbl, priv);
1788 struct hmdfs_peer *conn = work->conn;
1789 struct hmdfs_sb_info *sbi = conn->sbi;
1799 filp = hmdfs_open_stash_dir(&sbi->stash_work_dir, conn->cid);
1807 conn->need_rebuild_stash_list = true;
1813 conn->owner, conn->device_id,
1814 conn->need_rebuild_stash_list ? "" : "don't ");
1818 static void hmdfs_stash_add_do_check(struct hmdfs_peer *conn, int evt,
1821 struct hmdfs_sb_info *sbi = conn->sbi;
1823 .conn = conn,
1848 static void hmdfs_stash_online_prepare(struct hmdfs_peer *conn, int evt,
1851 struct hmdfs_sb_info *sbi = conn->sbi;
1858 !conn->need_rebuild_stash_list)
1862 mutex_unlock(&conn->seq_lock);
1864 filp = hmdfs_open_stash_dir(&sbi->stash_work_dir, conn->cid);
1869 err = hmdfs_iter_stash_file(conn, seq, filp,
1873 conn->owner, conn->device_id);
1875 WRITE_ONCE(conn->need_rebuild_stash_list, false);
1880 hmdfs_update_peer_rebuild_stats(&conn->stats.rebuild, &stats);
1882 conn->owner, conn->device_id, stats.total, stats.succeed,
1886 conn->stats.rebuild.time++;
1888 if (!READ_ONCE(conn->need_rebuild_stash_list)) {
1891 * writing @conn->need_rebuild_stash_list and
1892 * reading conn->rebuild_inode_status_nr.
1897 * accessing @conn->stashed_inode_list in restoring.
1899 wait_event(conn->rebuild_inode_status_wq,
1900 !atomic_read(&conn->rebuild_inode_status_nr));
1902 mutex_lock(&conn->seq_lock);
1919 static void hmdfs_stash_online_do_restore(struct hmdfs_peer *conn, int evt,
1922 struct hmdfs_sb_info *sbi = conn->sbi;
1928 if (!hmdfs_is_stash_enabled(sbi) || conn->need_rebuild_stash_list) {
1929 if (conn->need_rebuild_stash_list)
1931 conn->owner, conn->device_id);
1936 mutex_unlock(&conn->seq_lock);
1938 old_cred = hmdfs_override_creds(conn->sbi->cred);
1941 filp = hmdfs_open_stash_dir(&sbi->stash_work_dir, conn->cid);
1947 err = hmdfs_iter_stash_file(conn, seq, filp,
1956 hmdfs_drop_stashed_inodes(conn);
1958 hmdfs_update_peer_restore_stats(&conn->stats.restore, &stats);
1960 conn->owner, conn->device_id,
1963 mutex_lock(&conn->seq_lock);
1966 static void hmdfs_stash_del_do_cleanup(struct hmdfs_peer *conn, int evt,
1973 if (!hmdfs_is_stash_enabled(conn->sbi))
1978 list_for_each_entry_safe(info, next, &conn->wr_opened_inode_list,
1991 hmdfs_remote_del_wr_opened_inode(conn, info);
2000 hmdfs_info("release %u pinned inodes", conn->stashed_inode_nr);
2001 if (list_empty(&conn->stashed_inode_list))
2005 &conn->stashed_inode_list, stash_node)
2006 hmdfs_untrack_stashed_inode(conn, info);
2050 static int hmdfs_stash_write_local_file(struct hmdfs_peer *conn,
2067 old_cred = hmdfs_override_creds(conn->sbi->cred);
2076 conn->owner, conn->device_id, info->remote_ino,
2084 int hmdfs_stash_writepage(struct hmdfs_peer *conn,
2097 err = hmdfs_stash_write_local_file(conn, info, ctx, cache);
2109 static void hmdfs_stash_rebuild_status(struct hmdfs_peer *conn,
2127 conn->cid, info->remote_ino);
2131 conn->owner, conn->device_id, info->remote_ino);
2134 old_cred = hmdfs_override_creds(conn->sbi->cred);
2135 stash_path = &conn->sbi->stash_work_dir;
2144 hmdfs_track_inode_locked(conn, info);
2147 conn->owner, conn->device_id,
2155 conn->owner, conn->device_id, info->remote_ino,
2163 hmdfs_need_rebuild_inode_stash_status(struct hmdfs_peer *conn, umode_t mode)
2165 return hmdfs_is_stash_enabled(conn->sbi) &&
2166 READ_ONCE(conn->need_rebuild_stash_list) &&
2170 void hmdfs_remote_init_stash_status(struct hmdfs_peer *conn,
2173 if (!hmdfs_need_rebuild_inode_stash_status(conn, mode))
2176 atomic_inc(&conn->rebuild_inode_status_nr);
2179 * @conn->rebuild_inode_status_nr and reading
2180 * @conn->need_rebuild_stash_list.
2183 if (READ_ONCE(conn->need_rebuild_stash_list))
2184 hmdfs_stash_rebuild_status(conn, inode);
2185 if (atomic_dec_and_test(&conn->rebuild_inode_status_nr))
2186 wake_up(&conn->rebuild_inode_status_wq);