Lines Matching refs:sbi
277 struct hmdfs_sb_info *sbi = hmdfs_sb(sb);
278 struct super_block *lower_sb = sbi->lower_sb;
280 hmdfs_info("local_dst is %s, local_src is %s", sbi->local_dst,
281 sbi->local_src);
283 hmdfs_cfn_destroy(sbi);
284 hmdfs_unregister_sysfs(sbi);
285 hmdfs_connections_stop(sbi);
286 hmdfs_clear_share_table(sbi);
287 hmdfs_destroy_server_writeback(sbi);
288 hmdfs_exit_stash(sbi);
290 put_cred(sbi->cred);
291 if (sbi->system_cred)
292 put_cred(sbi->system_cred);
293 hmdfs_destroy_writeback(sbi);
294 kfree(sbi->local_src);
295 kfree(sbi->local_dst);
296 kfree(sbi->real_dst);
297 kfree(sbi->cache_dir);
298 kfree(sbi->cloud_dir);
299 kfifo_free(&sbi->notify_fifo);
301 sbi->lower_sb = NULL;
302 hmdfs_release_sysfs(sbi);
304 hmdfs_free_sb_seq(sbi->seq);
305 kfree(sbi->s_server_statis);
306 kfree(sbi->s_client_statis);
307 kfree(sbi);
338 struct hmdfs_sb_info *sbi = hmdfs_sb(dentry->d_inode->i_sb);
351 mutex_lock(&sbi->connections.node_lock);
352 list_for_each_entry(con, &sbi->connections.node_list, list) {
355 mutex_unlock(&sbi->connections.node_lock);
362 mutex_lock(&sbi->connections.node_lock);
365 mutex_unlock(&sbi->connections.node_lock);
379 struct hmdfs_sb_info *sbi = sb->s_fs_info;
385 err = kern_path(sbi->local_src, 0, &lower_path);
405 struct hmdfs_sb_info *sbi = hmdfs_sb(root->d_sb);
407 if (sbi->s_case_sensitive)
412 if (sbi->s_merge_switch)
418 seq_printf(m, ",user_id=%u", sbi->user_id);
420 if (sbi->cache_dir)
421 seq_printf(m, ",cache_dir=%s", sbi->cache_dir);
422 if (sbi->real_dst)
423 seq_printf(m, ",real_dst=%s", sbi->real_dst);
424 if (sbi->cloud_dir)
425 seq_printf(m, ",cloud_dir=%s", sbi->cloud_dir);
427 seq_printf(m, ",%soffline_stash", sbi->s_offline_stash ? "" : "no_");
428 seq_printf(m, ",%sdentry_cache", sbi->s_dentry_cache ? "" : "no_");
438 struct hmdfs_sb_info *sbi = hmdfs_sb(sb);
439 int syncfs_timeout = get_cmd_timeout(sbi, F_SYNCFS);
445 trace_hmdfs_syncfs_enter(sbi);
447 spin_lock(&sbi->hsi.list_lock);
448 if (!sbi->hsi.is_executing) {
449 sbi->hsi.is_executing = true;
451 spin_unlock(&sbi->hsi.list_lock);
454 list_add_tail(&item.list, &sbi->hsi.wait_list);
455 spin_unlock(&sbi->hsi.list_lock);
465 * during the waiting period we must protect @sbi->remote_syncfs_count
466 * and @sbi->remote_syncfs_ret from concurrent executing.
469 spin_lock(&sbi->hsi.v_lock);
470 sbi->hsi.version++;
472 * Attention: We put @sbi->hsi.remote_ret and @sbi->hsi.wait_count
477 * sbi->hsi.remote_ret = 0;
478 * atomic_set(&sbi->hsi.wait_count, 0);
481 * sbi->hsi.remote_ret = resp->ret_code
482 * atomic_dec(&sbi->hsi.wait_count);
488 * @sbi->hsi.remote_ret and @sbi->hsi.wait_count can be assigned
492 sbi->hsi.remote_ret = 0;
493 atomic_set(&sbi->hsi.wait_count, 0);
494 spin_unlock(&sbi->hsi.v_lock);
496 mutex_lock(&sbi->connections.node_lock);
497 list_for_each_entry(con, &sbi->connections.node_list, list) {
507 mutex_unlock(&sbi->connections.node_lock);
522 mutex_lock(&sbi->connections.node_lock);
530 sbi->hsi.remote_ret = err;
532 mutex_lock(&sbi->connections.node_lock);
536 atomic_inc(&sbi->hsi.wait_count);
539 mutex_lock(&sbi->connections.node_lock);
541 mutex_unlock(&sbi->connections.node_lock);
544 * Async work in background will make sure @sbi->remote_syncfs_count
548 sbi->hsi.wq, atomic_read(&sbi->hsi.wait_count) == 0);
554 if (!err && sbi->hsi.remote_ret)
555 err = sbi->hsi.remote_ret;
558 list_for_each_entry_safe(entry, tmp, &sbi->hsi.pending_list, list) {
562 INIT_LIST_HEAD(&sbi->hsi.pending_list);
565 spin_lock(&sbi->hsi.list_lock);
566 if (list_empty(&sbi->hsi.wait_list)) {
567 sbi->hsi.is_executing = false;
569 entry = list_last_entry(&sbi->hsi.wait_list, struct syncfs_item,
572 list_splice_init(&sbi->hsi.wait_list, &sbi->hsi.pending_list);
576 spin_unlock(&sbi->hsi.list_lock);
579 trace_hmdfs_syncfs_exit(sbi, atomic_read(&sbi->hsi.wait_count),
580 get_cmd_timeout(sbi, F_SYNCFS), err);
682 static void hmdfs_init_cmd_timeout(struct hmdfs_sb_info *sbi)
684 memset(sbi->s_cmd_timeout, 0xff, sizeof(sbi->s_cmd_timeout));
686 set_cmd_timeout(sbi, F_OPEN, TIMEOUT_COMMON);
687 set_cmd_timeout(sbi, F_RELEASE, TIMEOUT_NONE);
688 set_cmd_timeout(sbi, F_READPAGE, TIMEOUT_COMMON);
689 set_cmd_timeout(sbi, F_WRITEPAGE, TIMEOUT_COMMON);
690 set_cmd_timeout(sbi, F_ITERATE, TIMEOUT_30S);
691 set_cmd_timeout(sbi, F_CREATE, TIMEOUT_COMMON);
692 set_cmd_timeout(sbi, F_MKDIR, TIMEOUT_COMMON);
693 set_cmd_timeout(sbi, F_RMDIR, TIMEOUT_COMMON);
694 set_cmd_timeout(sbi, F_UNLINK, TIMEOUT_COMMON);
695 set_cmd_timeout(sbi, F_RENAME, TIMEOUT_COMMON);
696 set_cmd_timeout(sbi, F_SETATTR, TIMEOUT_COMMON);
697 set_cmd_timeout(sbi, F_STATFS, TIMEOUT_COMMON);
698 set_cmd_timeout(sbi, F_CONNECT_REKEY, TIMEOUT_NONE);
699 set_cmd_timeout(sbi, F_DROP_PUSH, TIMEOUT_NONE);
700 set_cmd_timeout(sbi, F_GETATTR, TIMEOUT_COMMON);
701 set_cmd_timeout(sbi, F_FSYNC, TIMEOUT_90S);
702 set_cmd_timeout(sbi, F_SYNCFS, TIMEOUT_30S);
703 set_cmd_timeout(sbi, F_GETXATTR, TIMEOUT_COMMON);
704 set_cmd_timeout(sbi, F_SETXATTR, TIMEOUT_COMMON);
705 set_cmd_timeout(sbi, F_LISTXATTR, TIMEOUT_COMMON);
708 static int hmdfs_init_sbi(struct hmdfs_sb_info *sbi)
712 ret = kfifo_alloc(&sbi->notify_fifo, PAGE_SIZE, GFP_KERNEL);
720 sbi->s_server_statis =
721 kzalloc(sizeof(*sbi->s_server_statis) * F_SIZE, GFP_KERNEL);
722 sbi->s_client_statis =
723 kzalloc(sizeof(*sbi->s_client_statis) * F_SIZE, GFP_KERNEL);
724 if (!sbi->s_server_statis || !sbi->s_client_statis) {
734 sbi->seq = ret;
737 spin_lock_init(&sbi->notify_fifo_lock);
738 mutex_init(&sbi->cmd_handler_mutex);
739 sbi->s_case_sensitive = false;
740 sbi->s_features = HMDFS_FEATURE_READPAGES |
743 sbi->s_merge_switch = false;
744 sbi->s_cloud_disk_switch = false;
745 sbi->dcache_threshold = DEFAULT_DCACHE_THRESHOLD;
746 sbi->dcache_precision = DEFAULT_DCACHE_PRECISION;
747 sbi->dcache_timeout = DEFAULT_DCACHE_TIMEOUT;
748 sbi->write_cache_timeout = DEFAULT_WRITE_CACHE_TIMEOUT;
749 hmdfs_init_cmd_timeout(sbi);
750 sbi->async_cb_delay = HMDFS_NODE_EVT_CB_DELAY;
751 sbi->async_req_max_active = DEFAULT_SRV_REQ_MAX_ACTIVE;
752 sbi->s_offline_stash = true;
753 sbi->s_dentry_cache = true;
754 sbi->wb_timeout_ms = HMDFS_DEF_WB_TIMEOUT_MS;
755 sbi->s_readpages_nr = HMDFS_READPAGES_NR_DEF;
757 atomic_set(&sbi->connections.conn_seq, 0);
758 mutex_init(&sbi->connections.node_lock);
759 INIT_LIST_HEAD(&sbi->connections.node_list);
761 ret = hmdfs_init_share_table(sbi);
764 init_waitqueue_head(&sbi->async_readdir_wq);
765 INIT_LIST_HEAD(&sbi->async_readdir_msg_list);
766 INIT_LIST_HEAD(&sbi->async_readdir_work_list);
767 spin_lock_init(&sbi->async_readdir_msg_lock);
768 spin_lock_init(&sbi->async_readdir_work_lock);
776 void hmdfs_client_resp_statis(struct hmdfs_sb_info *sbi, u8 cmd,
784 sbi->s_client_statis[cmd].delay_resp_cnt++;
787 sbi->s_client_statis[cmd].timeout_cnt++;
791 sbi->s_client_statis[cmd].total += duration;
792 sbi->s_client_statis[cmd].resp_cnt++;
793 if (sbi->s_client_statis[cmd].max < duration)
794 sbi->s_client_statis[cmd].max = duration;
801 static int hmdfs_update_dst(struct hmdfs_sb_info *sbi)
807 sbi->real_dst = kstrdup(sbi->local_dst, GFP_KERNEL);
808 if (!sbi->real_dst) {
812 kfree(sbi->local_dst);
813 sbi->local_dst = NULL;
815 len = strlen(sbi->real_dst) + strlen(path_local) + 1;
820 sbi->local_dst = kmalloc(len, GFP_KERNEL);
821 if (!sbi->local_dst) {
825 snprintf(sbi->local_dst, strlen(sbi->real_dst) + strlen(path_local) + 1,
826 "%s%s", sbi->real_dst, path_local);
860 struct hmdfs_sb_info *sbi;
872 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
873 if (!sbi) {
877 err = hmdfs_init_sbi(sbi);
880 sbi->sb = sb;
881 err = hmdfs_parse_options(sbi, raw_data);
885 sb->s_fs_info = sbi;
890 sbi->boot_cookie = hmdfs_gen_boot_cookie();
892 err = hmdfs_init_writeback(sbi);
895 err = hmdfs_init_server_writeback(sbi);
899 err = hmdfs_init_stash(sbi);
904 ctrl_hash = path_hash(sbi->local_dst, strlen(sbi->local_dst), true);
907 err = hmdfs_register_sysfs(ctrl_path, sbi);
911 err = hmdfs_update_dst(sbi);
924 sbi->lower_sb = lower_sb;
925 sbi->local_src = get_full_path(&lower_path);
926 if (!sbi->local_src) {
939 root_inode = fill_root_inode(sb, sbi, d_inode(lower_path.dentry));
950 if (sbi->s_cloud_disk_switch)
951 err = init_hmdfs_dentry_info(sbi, root_dentry, HMDFS_LAYER_SECOND_LOCAL);
953 err = init_hmdfs_dentry_info(sbi, root_dentry, HMDFS_LAYER_ZERO);
957 sbi->cred = get_cred(current_cred());
958 INIT_LIST_HEAD(&sbi->client_cache);
959 INIT_LIST_HEAD(&sbi->server_cache);
960 INIT_LIST_HEAD(&sbi->to_delete);
961 mutex_init(&sbi->cache_list_lock);
962 hmdfs_cfn_load(sbi);
965 spin_lock_init(&sbi->hsi.v_lock);
966 init_waitqueue_head(&sbi->hsi.wq);
967 sbi->hsi.version = 0;
968 sbi->hsi.is_executing = false;
969 INIT_LIST_HEAD(&sbi->hsi.wait_list);
970 INIT_LIST_HEAD(&sbi->hsi.pending_list);
971 spin_lock_init(&sbi->hsi.list_lock);
981 hmdfs_unregister_sysfs(sbi);
982 hmdfs_release_sysfs(sbi);
984 if (sbi) {
986 hmdfs_clear_share_table(sbi);
987 hmdfs_exit_stash(sbi);
988 hmdfs_destroy_writeback(sbi);
989 hmdfs_destroy_server_writeback(sbi);
990 kfifo_free(&sbi->notify_fifo);
991 hmdfs_free_sb_seq(sbi->seq);
992 kfree(sbi->local_src);
993 kfree(sbi->local_dst);
994 kfree(sbi->real_dst);
995 kfree(sbi->cache_dir);
996 kfree(sbi->cloud_dir);
997 kfree(sbi->s_server_statis);
998 kfree(sbi->s_client_statis);
999 kfree(sbi);
1020 static void hmdfs_cancel_async_readdir(struct hmdfs_sb_info *sbi)
1030 spin_lock(&sbi->async_readdir_work_lock);
1031 list_for_each_entry_safe(rw, tmp, &sbi->async_readdir_work_list, head) {
1035 spin_unlock(&sbi->async_readdir_work_lock);
1044 spin_lock(&sbi->async_readdir_msg_lock);
1045 sbi->async_readdir_prohibit = true;
1046 list_for_each_entry(msg_wq, &sbi->async_readdir_msg_list, async_msg)
1048 spin_unlock(&sbi->async_readdir_msg_lock);
1051 if (!list_empty(&sbi->async_readdir_work_list))
1052 wait_event_interruptible_timeout(sbi->async_readdir_wq,
1053 (list_empty(&sbi->async_readdir_work_list)), HZ);
1055 WARN_ON(!(list_empty(&sbi->async_readdir_work_list)));
1060 struct hmdfs_sb_info *sbi = hmdfs_sb(sb);
1067 if (sbi)
1068 hmdfs_cancel_async_readdir(sbi);