fs/cifsd/vfs_cache.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
   4  * Copyright (C) 2019 Samsung Electronics Co., Ltd.
   5  */
   6
   7 #include <linux/fs.h>
   8 #include <linux/slab.h>
   9 #include <linux/vmalloc.h>
  10
  11 #include "glob.h"
  12 #include "vfs_cache.h"
  13 #include "buffer_pool.h"
  14 #include "oplock.h"
  15 #include "vfs.h"
  16 #include "connection.h"
  17 #include "mgmt/tree_connect.h"
  18 #include "mgmt/user_session.h"
  19 #include "smb_common.h"
  20
  21 #define S_DEL_PENDING                   1
  22 #define S_DEL_ON_CLS                    2
  23 #define S_DEL_ON_CLS_STREAM             8
  24
  25 static unsigned int inode_hash_mask __read_mostly;
  26 static unsigned int inode_hash_shift __read_mostly;
  27 static struct hlist_head *inode_hashtable __read_mostly;
  28 static DEFINE_RWLOCK(inode_hash_lock);
  29
  30 static struct ksmbd_file_table global_ft;
  31 static atomic_long_t fd_limit;
  32
  33 void ksmbd_set_fd_limit(unsigned long limit)
  34 {
  35         limit = min(limit, get_max_files());
  36         atomic_long_set(&fd_limit, limit);
  37 }
  38
  39 static bool fd_limit_depleted(void)
  40 {
  41         long v = atomic_long_dec_return(&fd_limit);
  42
  43         if (v >= 0)
  44                 return false;
  45         atomic_long_inc(&fd_limit);
  46         return true;
  47 }
  48
  49 static void fd_limit_close(void)
  50 {
  51         atomic_long_inc(&fd_limit);
  52 }
  53
  54 /*
  55  * INODE hash
  56  */
  57
  58 static unsigned long inode_hash(struct super_block *sb, unsigned long hashval)
  59 {
  60         unsigned long tmp;
  61
  62         tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) /
  63                 L1_CACHE_BYTES;
  64         tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> inode_hash_shift);
  65         return tmp & inode_hash_mask;
  66 }
  67
  68 static struct ksmbd_inode *__ksmbd_inode_lookup(struct inode *inode)
  69 {
  70         struct hlist_head *head = inode_hashtable +
  71                 inode_hash(inode->i_sb, inode->i_ino);
  72         struct ksmbd_inode *ci = NULL, *ret_ci = NULL;
  73
  74         hlist_for_each_entry(ci, head, m_hash) {
  75                 if (ci->m_inode == inode) {
  76                         if (atomic_inc_not_zero(&ci->m_count))
  77                                 ret_ci = ci;
  78                         break;
  79                 }
  80         }
  81         return ret_ci;
  82 }
  83
  84 static struct ksmbd_inode *ksmbd_inode_lookup(struct ksmbd_file *fp)
  85 {
  86         return __ksmbd_inode_lookup(FP_INODE(fp));
  87 }
  88
  89 static struct ksmbd_inode *ksmbd_inode_lookup_by_vfsinode(struct inode *inode)
  90 {
  91         struct ksmbd_inode *ci;
  92
  93         read_lock(&inode_hash_lock);
  94         ci = __ksmbd_inode_lookup(inode);
  95         read_unlock(&inode_hash_lock);
  96         return ci;
  97 }
  98
  99 int ksmbd_query_inode_status(struct inode *inode)
 100 {
 101         struct ksmbd_inode *ci;
 102         int ret = KSMBD_INODE_STATUS_UNKNOWN;
 103
 104         read_lock(&inode_hash_lock);
 105         ci = __ksmbd_inode_lookup(inode);
 106         if (ci) {
 107                 ret = KSMBD_INODE_STATUS_OK;
 108                 if (ci->m_flags & S_DEL_PENDING)
 109                         ret = KSMBD_INODE_STATUS_PENDING_DELETE;
 110                 atomic_dec(&ci->m_count);
 111         }
 112         read_unlock(&inode_hash_lock);
 113         return ret;
 114 }
 115
 116 bool ksmbd_inode_pending_delete(struct ksmbd_file *fp)
 117 {
 118         return (fp->f_ci->m_flags & S_DEL_PENDING);
 119 }
 120
 121 void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp)
 122 {
 123         fp->f_ci->m_flags |= S_DEL_PENDING;
 124 }
 125
 126 void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp)
 127 {
 128         fp->f_ci->m_flags &= ~S_DEL_PENDING;
 129 }
 130
 131 void ksmbd_fd_set_delete_on_close(struct ksmbd_file *fp,
 132                                   int file_info)
 133 {
 134         if (ksmbd_stream_fd(fp)) {
 135                 fp->f_ci->m_flags |= S_DEL_ON_CLS_STREAM;
 136                 return;
 137         }
 138
 139         fp->f_ci->m_flags |= S_DEL_ON_CLS;
 140 }
 141
 142 static void ksmbd_inode_hash(struct ksmbd_inode *ci)
 143 {
 144         struct hlist_head *b = inode_hashtable +
 145                 inode_hash(ci->m_inode->i_sb, ci->m_inode->i_ino);
 146
 147         hlist_add_head(&ci->m_hash, b);
 148 }
 149
 150 static void ksmbd_inode_unhash(struct ksmbd_inode *ci)
 151 {
 152         write_lock(&inode_hash_lock);
 153         hlist_del_init(&ci->m_hash);
 154         write_unlock(&inode_hash_lock);
 155 }
 156
 157 static int ksmbd_inode_init(struct ksmbd_inode *ci, struct ksmbd_file *fp)
 158 {
 159         ci->m_inode = FP_INODE(fp);
 160         atomic_set(&ci->m_count, 1);
 161         atomic_set(&ci->op_count, 0);
 162         atomic_set(&ci->sop_count, 0);
 163         ci->m_flags = 0;
 164         ci->m_fattr = 0;
 165         INIT_LIST_HEAD(&ci->m_fp_list);
 166         INIT_LIST_HEAD(&ci->m_op_list);
 167         rwlock_init(&ci->m_lock);
 168         return 0;
 169 }
 170
 171 static struct ksmbd_inode *ksmbd_inode_get(struct ksmbd_file *fp)
 172 {
 173         struct ksmbd_inode *ci, *tmpci;
 174         int rc;
 175
 176         read_lock(&inode_hash_lock);
 177         ci = ksmbd_inode_lookup(fp);
 178         read_unlock(&inode_hash_lock);
 179         if (ci)
 180                 return ci;
 181
 182         ci = kmalloc(sizeof(struct ksmbd_inode), GFP_KERNEL);
 183         if (!ci)
 184                 return NULL;
 185
 186         rc = ksmbd_inode_init(ci, fp);
 187         if (rc) {
 188                 ksmbd_err("inode initialized failed\n");
 189                 kfree(ci);
 190                 return NULL;
 191         }
 192
 193         write_lock(&inode_hash_lock);
 194         tmpci = ksmbd_inode_lookup(fp);
 195         if (!tmpci) {
 196                 ksmbd_inode_hash(ci);
 197         } else {
 198                 kfree(ci);
 199                 ci = tmpci;
 200         }
 201         write_unlock(&inode_hash_lock);
 202         return ci;
 203 }
 204
 205 static void ksmbd_inode_free(struct ksmbd_inode *ci)
 206 {
 207         ksmbd_inode_unhash(ci);
 208         kfree(ci);
 209 }
 210
 211 static void ksmbd_inode_put(struct ksmbd_inode *ci)
 212 {
 213         if (atomic_dec_and_test(&ci->m_count))
 214                 ksmbd_inode_free(ci);
 215 }
 216
 217 int __init ksmbd_inode_hash_init(void)
 218 {
 219         unsigned int loop;
 220         unsigned long numentries = 16384;
 221         unsigned long bucketsize = sizeof(struct hlist_head);
 222         unsigned long size;
 223
 224         inode_hash_shift = ilog2(numentries);
 225         inode_hash_mask = (1 << inode_hash_shift) - 1;
 226
 227         size = bucketsize << inode_hash_shift;
 228
 229         /* init master fp hash table */
 230         inode_hashtable = vmalloc(size);
 231         if (!inode_hashtable)
 232                 return -ENOMEM;
 233
 234         for (loop = 0; loop < (1U << inode_hash_shift); loop++)
 235                 INIT_HLIST_HEAD(&inode_hashtable[loop]);
 236         return 0;
 237 }
 238
 239 void ksmbd_release_inode_hash(void)
 240 {
 241         vfree(inode_hashtable);
 242 }
 243
 244 static void __ksmbd_inode_close(struct ksmbd_file *fp)
 245 {
 246         struct dentry *dir, *dentry;
 247         struct ksmbd_inode *ci = fp->f_ci;
 248         int err;
 249         struct file *filp;
 250
 251         filp = fp->filp;
 252         if (ksmbd_stream_fd(fp) && (ci->m_flags & S_DEL_ON_CLS_STREAM)) {
 253                 ci->m_flags &= ~S_DEL_ON_CLS_STREAM;
 254                 err = ksmbd_vfs_remove_xattr(filp->f_path.dentry,
 255                                              fp->stream.name);
 256                 if (err)
 257                         ksmbd_err("remove xattr failed : %s\n",
 258                                   fp->stream.name);
 259         }
 260
 261         if (atomic_dec_and_test(&ci->m_count)) {
 262                 write_lock(&ci->m_lock);
 263                 if (ci->m_flags & (S_DEL_ON_CLS | S_DEL_PENDING)) {
 264                         dentry = filp->f_path.dentry;
 265                         dir = dentry->d_parent;
 266                         ci->m_flags &= ~(S_DEL_ON_CLS | S_DEL_PENDING);
 267                         write_unlock(&ci->m_lock);
 268                         ksmbd_vfs_unlink(dir, dentry);
 269                         write_lock(&ci->m_lock);
 270                 }
 271                 write_unlock(&ci->m_lock);
 272
 273                 ksmbd_inode_free(ci);
 274         }
 275 }
 276
 277 static void __ksmbd_remove_durable_fd(struct ksmbd_file *fp)
 278 {
 279         if (!HAS_FILE_ID(fp->persistent_id))
 280                 return;
 281
 282         write_lock(&global_ft.lock);
 283         idr_remove(global_ft.idr, fp->persistent_id);
 284         write_unlock(&global_ft.lock);
 285 }
 286
 287 static void __ksmbd_remove_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp)
 288 {
 289         if (!HAS_FILE_ID(fp->volatile_id))
 290                 return;
 291
 292         write_lock(&fp->f_ci->m_lock);
 293         list_del_init(&fp->node);
 294         write_unlock(&fp->f_ci->m_lock);
 295
 296         write_lock(&ft->lock);
 297         idr_remove(ft->idr, fp->volatile_id);
 298         write_unlock(&ft->lock);
 299 }
 300
 301 static void __ksmbd_close_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp)
 302 {
 303         struct file *filp;
 304
 305         fd_limit_close();
 306         __ksmbd_remove_durable_fd(fp);
 307         __ksmbd_remove_fd(ft, fp);
 308
 309         close_id_del_oplock(fp);
 310         filp = fp->filp;
 311
 312         __ksmbd_inode_close(fp);
 313         if (!IS_ERR_OR_NULL(filp))
 314                 fput(filp);
 315         kfree(fp->filename);
 316         if (ksmbd_stream_fd(fp))
 317                 kfree(fp->stream.name);
 318         ksmbd_free_file_struct(fp);
 319 }
 320
 321 static struct ksmbd_file *ksmbd_fp_get(struct ksmbd_file *fp)
 322 {
 323         if (!atomic_inc_not_zero(&fp->refcount))
 324                 return NULL;
 325         return fp;
 326 }
 327
 328 static struct ksmbd_file *__ksmbd_lookup_fd(struct ksmbd_file_table *ft,
 329                                             unsigned int id)
 330 {
 331         struct ksmbd_file *fp;
 332
 333         read_lock(&ft->lock);
 334         fp = idr_find(ft->idr, id);
 335         if (fp)
 336                 fp = ksmbd_fp_get(fp);
 337         read_unlock(&ft->lock);
 338         return fp;
 339 }
 340
 341 static void __put_fd_final(struct ksmbd_work *work, struct ksmbd_file *fp)
 342 {
 343         __ksmbd_close_fd(&work->sess->file_table, fp);
 344         atomic_dec(&work->conn->stats.open_files_count);
 345 }
 346
 347 static void set_close_state_blocked_works(struct ksmbd_file *fp)
 348 {
 349         struct ksmbd_work *cancel_work, *ctmp;
 350
 351         spin_lock(&fp->f_lock);
 352         list_for_each_entry_safe(cancel_work, ctmp, &fp->blocked_works,
 353                                  fp_entry) {
 354                 list_del(&cancel_work->fp_entry);
 355                 cancel_work->state = KSMBD_WORK_CLOSED;
 356                 cancel_work->cancel_fn(cancel_work->cancel_argv);
 357         }
 358         spin_unlock(&fp->f_lock);
 359 }
 360
 361 int ksmbd_close_fd(struct ksmbd_work *work, unsigned int id)
 362 {
 363         struct ksmbd_file       *fp;
 364         struct ksmbd_file_table *ft;
 365
 366         if (!HAS_FILE_ID(id))
 367                 return 0;
 368
 369         ft = &work->sess->file_table;
 370         read_lock(&ft->lock);
 371         fp = idr_find(ft->idr, id);
 372         if (fp) {
 373                 set_close_state_blocked_works(fp);
 374
 375                 if (!atomic_dec_and_test(&fp->refcount))
 376                         fp = NULL;
 377         }
 378         read_unlock(&ft->lock);
 379
 380         if (!fp)
 381                 return -EINVAL;
 382
 383         __put_fd_final(work, fp);
 384         return 0;
 385 }
 386
 387 void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp)
 388 {
 389         if (!fp)
 390                 return;
 391
 392         if (!atomic_dec_and_test(&fp->refcount))
 393                 return;
 394         __put_fd_final(work, fp);
 395 }
 396
 397 static bool __sanity_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)
 398 {
 399         if (!fp)
 400                 return false;
 401         if (fp->tcon != tcon)
 402                 return false;
 403         return true;
 404 }
 405
 406 struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, unsigned int id)
 407 {
 408         return __ksmbd_lookup_fd(&work->sess->file_table, id);
 409 }
 410
 411 struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, unsigned int id)
 412 {
 413         struct ksmbd_file *fp = __ksmbd_lookup_fd(&work->sess->file_table, id);
 414
 415         if (__sanity_check(work->tcon, fp))
 416                 return fp;
 417
 418         ksmbd_fd_put(work, fp);
 419         return NULL;
 420 }
 421
 422 struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, unsigned int id,
 423                                         unsigned int pid)
 424 {
 425         struct ksmbd_file *fp;
 426
 427         if (!HAS_FILE_ID(id)) {
 428                 id = work->compound_fid;
 429                 pid = work->compound_pfid;
 430         }
 431
 432         if (!HAS_FILE_ID(id))
 433                 return NULL;
 434
 435         fp = __ksmbd_lookup_fd(&work->sess->file_table, id);
 436         if (!__sanity_check(work->tcon, fp)) {
 437                 ksmbd_fd_put(work, fp);
 438                 return NULL;
 439         }
 440         if (fp->persistent_id != pid) {
 441                 ksmbd_fd_put(work, fp);
 442                 return NULL;
 443         }
 444         return fp;
 445 }
 446
 447 struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id)
 448 {
 449         return __ksmbd_lookup_fd(&global_ft, id);
 450 }
 451
 452 struct ksmbd_file *ksmbd_lookup_fd_cguid(char *cguid)
 453 {
 454         struct ksmbd_file       *fp = NULL;
 455         unsigned int            id;
 456
 457         read_lock(&global_ft.lock);
 458         idr_for_each_entry(global_ft.idr, fp, id) {
 459                 if (!memcmp(fp->create_guid,
 460                             cguid,
 461                             SMB2_CREATE_GUID_SIZE)) {
 462                         fp = ksmbd_fp_get(fp);
 463                         break;
 464                 }
 465         }
 466         read_unlock(&global_ft.lock);
 467
 468         return fp;
 469 }
 470
 471 struct ksmbd_file *ksmbd_lookup_fd_inode(struct inode *inode)
 472 {
 473         struct ksmbd_file       *lfp;
 474         struct ksmbd_inode      *ci;
 475         struct list_head        *cur;
 476
 477         ci = ksmbd_inode_lookup_by_vfsinode(inode);
 478         if (!ci)
 479                 return NULL;
 480
 481         read_lock(&ci->m_lock);
 482         list_for_each(cur, &ci->m_fp_list) {
 483                 lfp = list_entry(cur, struct ksmbd_file, node);
 484                 if (inode == FP_INODE(lfp)) {
 485                         atomic_dec(&ci->m_count);
 486                         read_unlock(&ci->m_lock);
 487                         return lfp;
 488                 }
 489         }
 490         atomic_dec(&ci->m_count);
 491         read_unlock(&ci->m_lock);
 492         return NULL;
 493 }
 494
 495 #define OPEN_ID_TYPE_VOLATILE_ID        (0)
 496 #define OPEN_ID_TYPE_PERSISTENT_ID      (1)
 497
 498 static void __open_id_set(struct ksmbd_file *fp, unsigned int id, int type)
 499 {
 500         if (type == OPEN_ID_TYPE_VOLATILE_ID)
 501                 fp->volatile_id = id;
 502         if (type == OPEN_ID_TYPE_PERSISTENT_ID)
 503                 fp->persistent_id = id;
 504 }
 505
 506 static int __open_id(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
 507                      int type)
 508 {
 509         unsigned int            id = 0;
 510         int                     ret;
 511
 512         if (type == OPEN_ID_TYPE_VOLATILE_ID && fd_limit_depleted()) {
 513                 __open_id_set(fp, KSMBD_NO_FID, type);
 514                 return -EMFILE;
 515         }
 516
 517         idr_preload(GFP_KERNEL);
 518         write_lock(&ft->lock);
 519         ret = idr_alloc_cyclic(ft->idr, fp, 0, INT_MAX, GFP_NOWAIT);
 520         if (ret >= 0) {
 521                 id = ret;
 522                 ret = 0;
 523         } else {
 524                 id = KSMBD_NO_FID;
 525                 fd_limit_close();
 526         }
 527
 528         __open_id_set(fp, id, type);
 529         write_unlock(&ft->lock);
 530         idr_preload_end();
 531         return ret;
 532 }
 533
 534 unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp)
 535 {
 536         __open_id(&global_ft, fp, OPEN_ID_TYPE_PERSISTENT_ID);
 537         return fp->persistent_id;
 538 }
 539
 540 struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp)
 541 {
 542         struct ksmbd_file       *fp;
 543         int ret;
 544
 545         fp = ksmbd_alloc_file_struct();
 546         if (!fp) {
 547                 ksmbd_err("Failed to allocate memory\n");
 548                 return ERR_PTR(-ENOMEM);
 549         }
 550
 551         INIT_LIST_HEAD(&fp->blocked_works);
 552         INIT_LIST_HEAD(&fp->node);
 553         spin_lock_init(&fp->f_lock);
 554         atomic_set(&fp->refcount, 1);
 555
 556         fp->filp                = filp;
 557         fp->conn                = work->sess->conn;
 558         fp->tcon                = work->tcon;
 559         fp->volatile_id         = KSMBD_NO_FID;
 560         fp->persistent_id       = KSMBD_NO_FID;
 561         fp->f_ci                = ksmbd_inode_get(fp);
 562
 563         if (!fp->f_ci) {
 564                 ksmbd_free_file_struct(fp);
 565                 return ERR_PTR(-ENOMEM);
 566         }
 567
 568         ret = __open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID);
 569         if (ret) {
 570                 ksmbd_inode_put(fp->f_ci);
 571                 ksmbd_free_file_struct(fp);
 572                 return ERR_PTR(ret);
 573         }
 574
 575         atomic_inc(&work->conn->stats.open_files_count);
 576         return fp;
 577 }
 578
 579 static int
 580 __close_file_table_ids(struct ksmbd_file_table *ft,
 581                        struct ksmbd_tree_connect *tcon,
 582                        bool (*skip)(struct ksmbd_tree_connect *tcon,
 583                                     struct ksmbd_file *fp))
 584 {
 585         unsigned int                    id;
 586         struct ksmbd_file               *fp;
 587         int                             num = 0;
 588
 589         idr_for_each_entry(ft->idr, fp, id) {
 590                 if (skip(tcon, fp))
 591                         continue;
 592
 593                 set_close_state_blocked_works(fp);
 594
 595                 if (!atomic_dec_and_test(&fp->refcount))
 596                         continue;
 597                 __ksmbd_close_fd(ft, fp);
 598                 num++;
 599         }
 600         return num;
 601 }
 602
 603 static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)
 604 {
 605         return fp->tcon != tcon;
 606 }
 607
 608 static bool session_fd_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)
 609 {
 610         return false;
 611 }
 612
 613 void ksmbd_close_tree_conn_fds(struct ksmbd_work *work)
 614 {
 615         int num = __close_file_table_ids(&work->sess->file_table,
 616                                          work->tcon,
 617                                          tree_conn_fd_check);
 618
 619         atomic_sub(num, &work->conn->stats.open_files_count);
 620 }
 621
 622 void ksmbd_close_session_fds(struct ksmbd_work *work)
 623 {
 624         int num = __close_file_table_ids(&work->sess->file_table,
 625                                          work->tcon,
 626                                          session_fd_check);
 627
 628         atomic_sub(num, &work->conn->stats.open_files_count);
 629 }
 630
 631 int ksmbd_init_global_file_table(void)
 632 {
 633         return ksmbd_init_file_table(&global_ft);
 634 }
 635
 636 void ksmbd_free_global_file_table(void)
 637 {
 638         struct ksmbd_file       *fp = NULL;
 639         unsigned int            id;
 640
 641         idr_for_each_entry(global_ft.idr, fp, id) {
 642                 __ksmbd_remove_durable_fd(fp);
 643                 ksmbd_free_file_struct(fp);
 644         }
 645
 646         ksmbd_destroy_file_table(&global_ft);
 647 }
 648
 649 int ksmbd_file_table_flush(struct ksmbd_work *work)
 650 {
 651         struct ksmbd_file       *fp = NULL;
 652         unsigned int            id;
 653         int                     ret;
 654
 655         read_lock(&work->sess->file_table.lock);
 656         idr_for_each_entry(work->sess->file_table.idr, fp, id) {
 657                 ret = ksmbd_vfs_fsync(work, fp->volatile_id, KSMBD_NO_FID);
 658                 if (ret)
 659                         break;
 660         }
 661         read_unlock(&work->sess->file_table.lock);
 662         return ret;
 663 }
 664
 665 int ksmbd_init_file_table(struct ksmbd_file_table *ft)
 666 {
 667         ft->idr = kzalloc(sizeof(struct idr), GFP_KERNEL);
 668         if (!ft->idr)
 669                 return -ENOMEM;
 670
 671         idr_init(ft->idr);
 672         rwlock_init(&ft->lock);
 673         return 0;
 674 }
 675
 676 void ksmbd_destroy_file_table(struct ksmbd_file_table *ft)
 677 {
 678         if (!ft->idr)
 679                 return;
 680
 681         __close_file_table_ids(ft, NULL, session_fd_check);
 682         idr_destroy(ft->idr);
 683         kfree(ft->idr);
 684         ft->idr = NULL;
 685 }