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);
861 struct hmdfs_sb_info *sbi;
873 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
874 if (!sbi) {
878 err = hmdfs_init_sbi(sbi);
881 sbi->sb = sb;
882 err = hmdfs_parse_options(sbi, raw_data);
886 sb->s_fs_info = sbi;
891 sbi->boot_cookie = hmdfs_gen_boot_cookie();
893 err = hmdfs_init_writeback(sbi);
896 err = hmdfs_init_server_writeback(sbi);
900 err = hmdfs_init_stash(sbi);
905 ctrl_hash = path_hash(sbi->local_dst, strlen(sbi->local_dst), true);
908 err = hmdfs_register_sysfs(ctrl_path, sbi);
912 err = hmdfs_update_dst(sbi);
925 sbi->lower_sb = lower_sb;
926 sbi->local_src = get_full_path(&lower_path);
927 if (!sbi->local_src) {
940 root_inode = fill_root_inode(sb, sbi, d_inode(lower_path.dentry));
951 if (sbi->s_cloud_disk_switch)
952 err = init_hmdfs_dentry_info(sbi, root_dentry, HMDFS_LAYER_SECOND_LOCAL);
954 err = init_hmdfs_dentry_info(sbi, root_dentry, HMDFS_LAYER_ZERO);
958 sbi->cred = get_cred(current_cred());
959 INIT_LIST_HEAD(&sbi->client_cache);
960 INIT_LIST_HEAD(&sbi->server_cache);
961 INIT_LIST_HEAD(&sbi->to_delete);
962 mutex_init(&sbi->cache_list_lock);
963 hmdfs_cfn_load(sbi);
966 spin_lock_init(&sbi->hsi.v_lock);
967 init_waitqueue_head(&sbi->hsi.wq);
968 sbi->hsi.version = 0;
969 sbi->hsi.is_executing = false;
970 INIT_LIST_HEAD(&sbi->hsi.wait_list);
971 INIT_LIST_HEAD(&sbi->hsi.pending_list);
972 spin_lock_init(&sbi->hsi.list_lock);
982 hmdfs_unregister_sysfs(sbi);
983 hmdfs_release_sysfs(sbi);
985 if (sbi) {
987 hmdfs_clear_share_table(sbi);
988 hmdfs_exit_stash(sbi);
989 hmdfs_destroy_writeback(sbi);
990 hmdfs_destroy_server_writeback(sbi);
991 kfifo_free(&sbi->notify_fifo);
992 hmdfs_free_sb_seq(sbi->seq);
993 kfree(sbi->local_src);
994 kfree(sbi->local_dst);
995 kfree(sbi->real_dst);
996 kfree(sbi->cache_dir);
997 kfree(sbi->cloud_dir);
998 kfree(sbi->s_server_statis);
999 kfree(sbi->s_client_statis);
1000 kfree(sbi);
1021 static void hmdfs_cancel_async_readdir(struct hmdfs_sb_info *sbi)
1031 spin_lock(&sbi->async_readdir_work_lock);
1032 list_for_each_entry_safe(rw, tmp, &sbi->async_readdir_work_list, head) {
1036 spin_unlock(&sbi->async_readdir_work_lock);
1045 spin_lock(&sbi->async_readdir_msg_lock);
1046 sbi->async_readdir_prohibit = true;
1047 list_for_each_entry(msg_wq, &sbi->async_readdir_msg_list, async_msg)
1049 spin_unlock(&sbi->async_readdir_msg_lock);
1052 if (!list_empty(&sbi->async_readdir_work_list))
1053 wait_event_interruptible_timeout(sbi->async_readdir_wq,
1054 (list_empty(&sbi->async_readdir_work_list)), HZ);
1056 WARN_ON(!(list_empty(&sbi->async_readdir_work_list)));
1061 struct hmdfs_sb_info *sbi = hmdfs_sb(sb);
1068 if (sbi)
1069 hmdfs_cancel_async_readdir(sbi);