Lines Matching defs:conn
67 struct hmdfs_peer *conn;
102 struct hmdfs_peer *conn;
143 struct hmdfs_peer *conn;
286 struct hmdfs_peer *conn = info->conn;
305 conn->owner, conn->device_id,
318 conn->owner, conn->device_id, info->remote_ino,
328 conn->owner, conn->device_id, info->remote_ino,
337 static void hmdfs_wait_remote_writeback_once(struct hmdfs_peer *conn,
353 conn->owner, conn->device_id, info->remote_ino);
359 static void hmdfs_reset_remote_write_err(struct hmdfs_peer *conn,
373 conn->owner, conn->device_id, info->remote_ino,
397 static int hmdfs_flush_stash_file_data(struct hmdfs_peer *conn,
412 hmdfs_reset_remote_write_err(conn, info);
423 hmdfs_wait_remote_writeback_once(conn, info);
426 hmdfs_reset_remote_write_err(conn, info);
439 conn->owner, conn->device_id,
447 conn->owner, conn->device_id, info->remote_ino,
458 err = hmdfs_flush_stash_file_data(info->conn, info);
523 static int hmdfs_close_stash_file(struct hmdfs_peer *conn,
533 conn->owner, conn->device_id, info->remote_ino,
559 hmdfs_new_file_cache(struct hmdfs_peer *conn, struct hmdfs_inode_info *info)
587 conn->owner, conn->device_id,
594 conn->owner, conn->device_id, info->remote_ino);
605 cache->cache_file = hmdfs_new_stash_file(&conn->sbi->stash_work_dir,
606 conn->cid);
621 static void hmdfs_init_stash_file_cache(struct hmdfs_peer *conn,
626 cache = hmdfs_new_file_cache(conn, info);
668 struct hmdfs_peer *conn = info->conn;
673 conn->owner, conn->device_id, info->remote_ino);
677 err = hmdfs_close_stash_file(conn, info);
698 static void hmdfs_init_cache_for_stash_files(struct hmdfs_peer *conn,
705 old_cred = hmdfs_override_creds(conn->sbi->cred);
707 hmdfs_init_stash_file_cache(conn, info);
716 hmdfs_init_cache_for_stash_files(work->conn, work->list);
720 static void hmdfs_init_cache_for_stash_files_by_work(struct hmdfs_peer *conn,
724 .conn = conn,
734 static void hmdfs_stash_fetch_ready_files(struct hmdfs_peer *conn,
739 spin_lock(&conn->wr_opened_inode_lock);
740 list_for_each_entry(info, &conn->wr_opened_inode_list, wr_opened_node) {
751 hmdfs_remote_add_wr_opened_inode_nolock(conn, info);
756 conn->owner, conn->device_id,
760 spin_unlock(&conn->wr_opened_inode_lock);
763 static void hmdfs_stash_offline_prepare(struct hmdfs_peer *conn, int evt,
768 if (!hmdfs_is_stash_enabled(conn->sbi))
771 mutex_lock(&conn->offline_cb_lock);
773 hmdfs_stash_fetch_ready_files(conn, true, &preparing);
778 hmdfs_init_cache_for_stash_files_by_work(conn, &preparing);
780 mutex_unlock(&conn->offline_cb_lock);
783 static void hmdfs_track_inode_locked(struct hmdfs_peer *conn,
786 spin_lock(&conn->stashed_inode_lock);
787 list_add_tail(&info->stash_node, &conn->stashed_inode_list);
788 conn->stashed_inode_nr++;
789 spin_unlock(&conn->stashed_inode_lock);
806 static void hmdfs_stash_remote_inodes(struct hmdfs_peer *conn,
815 old_cred = hmdfs_override_creds(conn->sbi->cred);
825 hmdfs_track_inode_locked(conn, info);
827 hmdfs_remote_del_wr_opened_inode(conn, info);
833 hmdfs_update_peer_stash_stats(&conn->stats.stash, &stats);
835 conn->owner, conn->device_id, conn->stashed_inode_nr,
839 static void hmdfs_stash_offline_do_stash(struct hmdfs_peer *conn, int evt,
846 if (!hmdfs_is_stash_enabled(conn->sbi))
850 mutex_unlock(&conn->seq_lock);
852 mutex_lock(&conn->offline_cb_lock);
854 hmdfs_stash_fetch_ready_files(conn, false, &preparing);
856 hmdfs_init_cache_for_stash_files(conn, &preparing);
858 spin_lock(&conn->wr_opened_inode_lock);
859 list_for_each_entry(info, &conn->wr_opened_inode_list, wr_opened_node) {
865 spin_unlock(&conn->wr_opened_inode_lock);
870 hmdfs_stash_remote_inodes(conn, &stashing);
873 mutex_unlock(&conn->offline_cb_lock);
874 mutex_lock(&conn->seq_lock);
878 hmdfs_lookup_stash_inode(struct hmdfs_peer *conn, uint64_t inum)
882 list_for_each_entry(info, &conn->stashed_inode_list, stash_node) {
890 static void hmdfs_untrack_stashed_inode(struct hmdfs_peer *conn,
896 conn->stashed_inode_nr--;
899 static void hmdfs_reset_stashed_inode(struct hmdfs_peer *conn,
909 hmdfs_untrack_stashed_inode(conn, info);
920 static void hmdfs_drop_stashed_inodes(struct hmdfs_peer *conn)
925 if (list_empty(&conn->stashed_inode_list))
929 conn->owner, conn->device_id, conn->stashed_inode_nr);
932 &conn->stashed_inode_list, stash_node) {
934 conn->owner, conn->device_id, info->remote_ino,
937 hmdfs_reset_stashed_inode(conn, info);
1081 static inline bool hmdfs_is_node_offlined(const struct hmdfs_peer *conn,
1091 return hmdfs_node_evt_seq(conn) != seq;
1098 struct hmdfs_peer *conn = ctx->conn;
1106 conn->owner, conn->device_id, ctx->inum,
1118 conn->owner, conn->device_id, ctx->inum,
1126 conn->owner, conn->device_id, ctx->inum,
1136 conn->owner, conn->device_id, ctx->inum,
1146 conn->owner, conn->device_id, ctx->inum,
1154 conn->owner, conn->device_id, ctx->inum,
1163 conn->owner, conn->device_id, ctx->inum,
1171 conn->owner, conn->device_id, ctx->inum,
1183 struct hmdfs_peer *conn = ctx->conn;
1199 conn->owner, conn->device_id, ctx->inum, err);
1207 conn->owner, conn->device_id, ctx->inum,
1219 conn->owner, conn->device_id, ctx->inum, err);
1237 conn->owner, conn->device_id, ctx->inum, err);
1243 conn->owner, conn->device_id, ctx->inum);
1255 struct hmdfs_peer *conn = ctx->conn;
1269 if (hmdfs_is_node_offlined(conn, ctx->seq))
1293 ctx->conn->owner, ctx->conn->device_id, ctx->inum);
1295 opened->conn ? opened->conn->owner : 0,
1296 opened->conn ? opened->conn->device_id : 0,
1300 pinned->conn->owner, pinned->conn->device_id,
1318 static ssize_t hmdfs_write_dst(struct hmdfs_peer *conn, struct file *filp,
1349 conn->owner, conn->device_id, info->remote_ino,
1357 static int hmdfs_rd_src_wr_dst(struct hmdfs_peer *conn,
1374 conn->owner, conn->device_id, args->inum, err);
1381 err = hmdfs_write_dst(conn, args->dst, args->buf, rd, ctx->dst_pos);
1384 else if (hmdfs_is_node_offlined(conn, args->seq))
1390 static int hmdfs_copy_src_to_dst(struct hmdfs_peer *conn,
1417 conn->owner, conn->device_id,
1423 conn->owner, conn->device_id,
1430 conn->owner, conn->device_id, args->inum, data_pos);
1434 err = hmdfs_rd_src_wr_dst(conn, &ctx);
1454 err = hmdfs_copy_src_to_dst(ctx->conn, &args);
1461 if (hmdfs_is_node_offlined(ctx->conn, ctx->seq))
1478 struct hmdfs_peer *conn = ctx->conn;
1486 conn->owner, conn->device_id, inum);
1488 pinned_info = hmdfs_lookup_stash_inode(conn, inum);
1494 conn->owner, conn->device_id, inum, status);
1500 conn->owner, conn->device_id, inum);
1523 hmdfs_reset_stashed_inode(conn, pinned_info);
1527 conn->owner, conn->device_id, inum, err, ctx->keep);
1532 static int hmdfs_init_file_restore_ctx(struct hmdfs_peer *conn,
1536 struct hmdfs_sb_info *sbi = conn->sbi;
1559 ctx->conn = conn;
1638 static int hmdfs_restore_files(struct hmdfs_peer *conn,
1648 err = hmdfs_init_file_restore_ctx(conn, seq, dir, &ctx);
1695 static int hmdfs_rebuild_stash_list(struct hmdfs_peer *conn,
1706 err = hmdfs_init_file_restore_ctx(conn, seq, dir, &ctx);
1746 conn->owner, conn->device_id, ctx.inum,
1761 static int hmdfs_iter_stash_file(struct hmdfs_peer *conn,
1791 err = op(conn, seq, &dir, tbl, priv);
1803 struct hmdfs_peer *conn = work->conn;
1804 struct hmdfs_sb_info *sbi = conn->sbi;
1814 filp = hmdfs_open_stash_dir(&sbi->stash_work_dir, conn->cid);
1822 conn->need_rebuild_stash_list = true;
1828 conn->owner, conn->device_id,
1829 conn->need_rebuild_stash_list ? "" : "don't ");
1833 static void hmdfs_stash_add_do_check(struct hmdfs_peer *conn, int evt,
1836 struct hmdfs_sb_info *sbi = conn->sbi;
1838 .conn = conn,
1863 static void hmdfs_stash_online_prepare(struct hmdfs_peer *conn, int evt,
1866 struct hmdfs_sb_info *sbi = conn->sbi;
1873 !conn->need_rebuild_stash_list)
1877 mutex_unlock(&conn->seq_lock);
1879 filp = hmdfs_open_stash_dir(&sbi->stash_work_dir, conn->cid);
1884 err = hmdfs_iter_stash_file(conn, seq, filp,
1888 conn->owner, conn->device_id);
1890 WRITE_ONCE(conn->need_rebuild_stash_list, false);
1895 hmdfs_update_peer_rebuild_stats(&conn->stats.rebuild, &stats);
1897 conn->owner, conn->device_id, stats.total, stats.succeed,
1901 conn->stats.rebuild.time++;
1903 if (!READ_ONCE(conn->need_rebuild_stash_list)) {
1906 * writing @conn->need_rebuild_stash_list and
1907 * reading conn->rebuild_inode_status_nr.
1912 * accessing @conn->stashed_inode_list in restoring.
1914 wait_event(conn->rebuild_inode_status_wq,
1915 !atomic_read(&conn->rebuild_inode_status_nr));
1917 mutex_lock(&conn->seq_lock);
1934 static void hmdfs_stash_online_do_restore(struct hmdfs_peer *conn, int evt,
1937 struct hmdfs_sb_info *sbi = conn->sbi;
1943 if (!hmdfs_is_stash_enabled(sbi) || conn->need_rebuild_stash_list) {
1944 if (conn->need_rebuild_stash_list)
1946 conn->owner, conn->device_id);
1951 mutex_unlock(&conn->seq_lock);
1953 old_cred = hmdfs_override_creds(conn->sbi->cred);
1956 filp = hmdfs_open_stash_dir(&sbi->stash_work_dir, conn->cid);
1962 err = hmdfs_iter_stash_file(conn, seq, filp,
1971 hmdfs_drop_stashed_inodes(conn);
1973 hmdfs_update_peer_restore_stats(&conn->stats.restore, &stats);
1975 conn->owner, conn->device_id,
1978 mutex_lock(&conn->seq_lock);
1981 static void hmdfs_stash_del_do_cleanup(struct hmdfs_peer *conn, int evt,
1988 if (!hmdfs_is_stash_enabled(conn->sbi))
1993 list_for_each_entry_safe(info, next, &conn->wr_opened_inode_list,
2006 hmdfs_remote_del_wr_opened_inode(conn, info);
2015 hmdfs_info("release %u pinned inodes", conn->stashed_inode_nr);
2016 if (list_empty(&conn->stashed_inode_list))
2020 &conn->stashed_inode_list, stash_node)
2021 hmdfs_untrack_stashed_inode(conn, info);
2065 static int hmdfs_stash_write_local_file(struct hmdfs_peer *conn,
2082 old_cred = hmdfs_override_creds(conn->sbi->cred);
2091 conn->owner, conn->device_id, info->remote_ino,
2099 int hmdfs_stash_writepage(struct hmdfs_peer *conn,
2112 err = hmdfs_stash_write_local_file(conn, info, ctx, cache);
2124 static void hmdfs_stash_rebuild_status(struct hmdfs_peer *conn,
2142 conn->cid, info->remote_ino);
2146 conn->owner, conn->device_id, info->remote_ino);
2149 old_cred = hmdfs_override_creds(conn->sbi->cred);
2150 stash_path = &conn->sbi->stash_work_dir;
2159 hmdfs_track_inode_locked(conn, info);
2162 conn->owner, conn->device_id,
2170 conn->owner, conn->device_id, info->remote_ino,
2178 hmdfs_need_rebuild_inode_stash_status(struct hmdfs_peer *conn, umode_t mode)
2180 return hmdfs_is_stash_enabled(conn->sbi) &&
2181 READ_ONCE(conn->need_rebuild_stash_list) &&
2185 void hmdfs_remote_init_stash_status(struct hmdfs_peer *conn,
2188 if (!hmdfs_need_rebuild_inode_stash_status(conn, mode))
2191 atomic_inc(&conn->rebuild_inode_status_nr);
2194 * @conn->rebuild_inode_status_nr and reading
2195 * @conn->need_rebuild_stash_list.
2198 if (READ_ONCE(conn->need_rebuild_stash_list))
2199 hmdfs_stash_rebuild_status(conn, inode);
2200 if (atomic_dec_and_test(&conn->rebuild_inode_status_nr))
2201 wake_up(&conn->rebuild_inode_status_wq);