fs/reiser4/inode.c

   1 /* Copyright 2001, 2002, 2003 by Hans Reiser, licensing governed by reiser4/README */
   2
   3 /* Inode specific operations. */
   4
   5 #include "forward.h"
   6 #include "debug.h"
   7 #include "key.h"
   8 #include "kassign.h"
   9 #include "coord.h"
  10 #include "seal.h"
  11 #include "dscale.h"
  12 #include "plugin/item/item.h"
  13 #include "plugin/security/perm.h"
  14 #include "plugin/plugin.h"
  15 #include "plugin/object.h"
  16 #include "znode.h"
  17 #include "vfs_ops.h"
  18 #include "inode.h"
  19 #include "super.h"
  20 #include "reiser4.h"
  21
  22 #include <linux/fs.h>           /* for struct super_block,  address_space */
  23
  24 /* return reiser4 internal tree which inode belongs to */
  25 /* Audited by: green(2002.06.17) */
  26 reiser4_tree *reiser4_tree_by_inode(const struct inode *inode /* inode queried */ )
  27 {
  28         assert("nikita-256", inode != NULL);
  29         assert("nikita-257", inode->i_sb != NULL);
  30         return reiser4_get_tree(inode->i_sb);
  31 }
  32
  33 /* return reiser4-specific inode flags */
  34 static inline unsigned long *inode_flags(const struct inode *const inode)
  35 {
  36         assert("nikita-2842", inode != NULL);
  37         return &reiser4_inode_data(inode)->flags;
  38 }
  39
  40 /* set reiser4-specific flag @f in @inode */
  41 void reiser4_inode_set_flag(struct inode *inode, reiser4_file_plugin_flags f)
  42 {
  43         assert("nikita-2248", inode != NULL);
  44         set_bit((int)f, inode_flags(inode));
  45 }
  46
  47 /* clear reiser4-specific flag @f in @inode */
  48 void reiser4_inode_clr_flag(struct inode *inode, reiser4_file_plugin_flags f)
  49 {
  50         assert("nikita-2250", inode != NULL);
  51         clear_bit((int)f, inode_flags(inode));
  52 }
  53
  54 /* true if reiser4-specific flag @f is set in @inode */
  55 int reiser4_inode_get_flag(const struct inode *inode,
  56                            reiser4_file_plugin_flags f)
  57 {
  58         assert("nikita-2251", inode != NULL);
  59         return test_bit((int)f, inode_flags(inode));
  60 }
  61
  62 /* convert oid to inode number */
  63 ino_t oid_to_ino(oid_t oid)
  64 {
  65         return (ino_t) oid;
  66 }
  67
  68 /* convert oid to user visible inode number */
  69 ino_t oid_to_uino(oid_t oid)
  70 {
  71         /* reiser4 object is uniquely identified by oid which is 64 bit
  72            quantity. Kernel in-memory inode is indexed (in the hash table) by
  73            32 bit i_ino field, but this is not a problem, because there is a
  74            way to further distinguish inodes with identical inode numbers
  75            (find_actor supplied to iget()).
  76
  77            But user space expects unique 32 bit inode number. Obviously this
  78            is impossible. Work-around is to somehow hash oid into user visible
  79            inode number.
  80          */
  81         oid_t max_ino = (ino_t) ~ 0;
  82
  83         if (REISER4_INO_IS_OID || (oid <= max_ino))
  84                 return oid;
  85         else
  86                 /* this is remotely similar to algorithm used to find next pid
  87                    to use for process: after wrap-around start from some
  88                    offset rather than from 0. Idea is that there are some long
  89                    living objects with which we don't want to collide.
  90                  */
  91                 return REISER4_UINO_SHIFT + ((oid - max_ino) & (max_ino >> 1));
  92 }
  93
  94 /* check that "inode" is on reiser4 file-system */
  95 int is_reiser4_inode(const struct inode *inode /* inode queried */ )
  96 {
  97         return inode != NULL && is_reiser4_super(inode->i_sb);
  98 }
  99
 100 /* Maximal length of a name that can be stored in directory @inode.
 101
 102    This is used in check during file creation and lookup. */
 103 int reiser4_max_filename_len(const struct inode *inode /* inode queried */ )
 104 {
 105         assert("nikita-287", is_reiser4_inode(inode));
 106         assert("nikita-1710", inode_dir_item_plugin(inode));
 107         if (inode_dir_item_plugin(inode)->s.dir.max_name_len)
 108                 return inode_dir_item_plugin(inode)->s.dir.max_name_len(inode);
 109         else
 110                 return 255;
 111 }
 112
 113 #if REISER4_USE_COLLISION_LIMIT
 114 /* Maximal number of hash collisions for this directory. */
 115 int max_hash_collisions(const struct inode *dir /* inode queried */ )
 116 {
 117         assert("nikita-1711", dir != NULL);
 118         return reiser4_inode_data(dir)->plugin.max_collisions;
 119 }
 120 #endif  /*  REISER4_USE_COLLISION_LIMIT  */
 121
 122 /* Install file, inode, and address_space operation on @inode, depending on
 123    its mode. */
 124 int setup_inode_ops(struct inode *inode /* inode to intialize */ ,
 125                     reiser4_object_create_data * data   /* parameters to create
 126                                                          * object */ )
 127 {
 128         reiser4_super_info_data *sinfo;
 129         file_plugin *fplug;
 130         dir_plugin *dplug;
 131
 132         fplug = inode_file_plugin(inode);
 133         dplug = inode_dir_plugin(inode);
 134
 135         sinfo = get_super_private(inode->i_sb);
 136
 137         switch (inode->i_mode & S_IFMT) {
 138         case S_IFSOCK:
 139         case S_IFBLK:
 140         case S_IFCHR:
 141         case S_IFIFO:
 142                 {
 143                         dev_t rdev;     /* to keep gcc happy */
 144
 145                         assert("vs-46", fplug != NULL);
 146                         /* ugly hack with rdev */
 147                         if (data == NULL) {
 148                                 rdev = inode->i_rdev;
 149                                 inode->i_rdev = 0;
 150                         } else
 151                                 rdev = data->rdev;
 152                         inode->i_blocks = 0;
 153                         assert("vs-42", fplug->h.id == SPECIAL_FILE_PLUGIN_ID);
 154                         inode->i_op = &file_plugins[fplug->h.id].inode_ops;
 155                         /* initialize inode->i_fop and inode->i_rdev for block and char
 156                            devices */
 157                         init_special_inode(inode, inode->i_mode, rdev);
 158                         /* all address space operations are null */
 159                         inode->i_mapping->a_ops =
 160                             &file_plugins[fplug->h.id].as_ops;
 161                         break;
 162                 }
 163         case S_IFLNK:
 164                 assert("vs-46", fplug != NULL);
 165                 assert("vs-42", fplug->h.id == SYMLINK_FILE_PLUGIN_ID);
 166                 inode->i_op = &file_plugins[fplug->h.id].inode_ops;
 167                 inode->i_fop = NULL;
 168                 /* all address space operations are null */
 169                 inode->i_mapping->a_ops = &file_plugins[fplug->h.id].as_ops;
 170                 break;
 171         case S_IFDIR:
 172                 assert("vs-46", dplug != NULL);
 173                 assert("vs-43", (dplug->h.id == HASHED_DIR_PLUGIN_ID ||
 174                                  dplug->h.id == SEEKABLE_HASHED_DIR_PLUGIN_ID));
 175                 inode->i_op = &dir_plugins[dplug->h.id].inode_ops;
 176                 inode->i_fop = &dir_plugins[dplug->h.id].file_ops;
 177                 inode->i_mapping->a_ops = &dir_plugins[dplug->h.id].as_ops;
 178                 break;
 179         case S_IFREG:
 180                 assert("vs-46", fplug != NULL);
 181                 assert("vs-43", (fplug->h.id == UNIX_FILE_PLUGIN_ID ||
 182                                  fplug->h.id == CRYPTCOMPRESS_FILE_PLUGIN_ID));
 183                 inode->i_op = &file_plugins[fplug->h.id].inode_ops;
 184                 inode->i_fop = &file_plugins[fplug->h.id].file_ops;
 185                 inode->i_mapping->a_ops = &file_plugins[fplug->h.id].as_ops;
 186                 break;
 187         default:
 188                 warning("nikita-291", "wrong file mode: %o for %llu",
 189                         inode->i_mode,
 190                         (unsigned long long)get_inode_oid(inode));
 191                 reiser4_make_bad_inode(inode);
 192                 return RETERR(-EINVAL);
 193         }
 194         return 0;
 195 }
 196
 197 /* Initialize inode from disk data. Called with inode locked.
 198    Return inode locked. */
 199 static int init_inode(struct inode *inode /* inode to intialise */ ,
 200                       coord_t * coord /* coord of stat data */ )
 201 {
 202         int result;
 203         item_plugin *iplug;
 204         void *body;
 205         int length;
 206         reiser4_inode *state;
 207
 208         assert("nikita-292", coord != NULL);
 209         assert("nikita-293", inode != NULL);
 210
 211         coord_clear_iplug(coord);
 212         result = zload(coord->node);
 213         if (result)
 214                 return result;
 215         iplug = item_plugin_by_coord(coord);
 216         body = item_body_by_coord(coord);
 217         length = item_length_by_coord(coord);
 218
 219         assert("nikita-295", iplug != NULL);
 220         assert("nikita-296", body != NULL);
 221         assert("nikita-297", length > 0);
 222
 223         /* inode is under I_LOCK now */
 224
 225         state = reiser4_inode_data(inode);
 226         /* call stat-data plugin method to load sd content into inode */
 227         result = iplug->s.sd.init_inode(inode, body, length);
 228         set_plugin(&state->pset, PSET_SD, item_plugin_to_plugin(iplug));
 229         if (result == 0) {
 230                 result = setup_inode_ops(inode, NULL);
 231                 if (result == 0 && inode->i_sb->s_root &&
 232                     inode->i_sb->s_root->d_inode)
 233                         result = finish_pset(inode);
 234         }
 235         zrelse(coord->node);
 236         return result;
 237 }
 238
 239 /* read `inode' from the disk. This is what was previously in
 240    reiserfs_read_inode2().
 241
 242    Must be called with inode locked. Return inode still locked.
 243 */
 244 static int read_inode(struct inode *inode /* inode to read from disk */ ,
 245                       const reiser4_key * key /* key of stat data */ ,
 246                       int silent)
 247 {
 248         int result;
 249         lock_handle lh;
 250         reiser4_inode *info;
 251         coord_t coord;
 252
 253         assert("nikita-298", inode != NULL);
 254         assert("nikita-1945", !is_inode_loaded(inode));
 255
 256         info = reiser4_inode_data(inode);
 257         assert("nikita-300", info->locality_id != 0);
 258
 259         coord_init_zero(&coord);
 260         init_lh(&lh);
 261         /* locate stat-data in a tree and return znode locked */
 262         result = lookup_sd(inode, ZNODE_READ_LOCK, &coord, &lh, key, silent);
 263         assert("nikita-301", !is_inode_loaded(inode));
 264         if (result == 0) {
 265                 /* use stat-data plugin to load sd into inode. */
 266                 result = init_inode(inode, &coord);
 267                 if (result == 0) {
 268                         /* initialize stat-data seal */
 269                         spin_lock_inode(inode);
 270                         reiser4_seal_init(&info->sd_seal, &coord, key);
 271                         info->sd_coord = coord;
 272                         spin_unlock_inode(inode);
 273
 274                         /* call file plugin's method to initialize plugin
 275                          * specific part of inode */
 276                         if (inode_file_plugin(inode)->init_inode_data)
 277                                 inode_file_plugin(inode)->init_inode_data(inode,
 278                                                                           NULL,
 279                                                                           0);
 280                         /* load detached directory cursors for stateless
 281                          * directory readers (NFS). */
 282                         reiser4_load_cursors(inode);
 283
 284                         /* Check the opened inode for consistency. */
 285                         result =
 286                             get_super_private(inode->i_sb)->df_plug->
 287                             check_open(inode);
 288                 }
 289         }
 290         /* lookup_sd() doesn't release coord because we want znode
 291            stay read-locked while stat-data fields are accessed in
 292            init_inode() */
 293         done_lh(&lh);
 294
 295         if (result != 0)
 296                 reiser4_make_bad_inode(inode);
 297         return result;
 298 }
 299
 300 /* initialise new reiser4 inode being inserted into hash table. */
 301 static int init_locked_inode(struct inode *inode /* new inode */ ,
 302                              void *opaque       /* key of stat data passed to the
 303                                                  * iget5_locked as cookie */ )
 304 {
 305         reiser4_key *key;
 306
 307         assert("nikita-1995", inode != NULL);
 308         assert("nikita-1996", opaque != NULL);
 309         key = opaque;
 310         set_inode_oid(inode, get_key_objectid(key));
 311         reiser4_inode_data(inode)->locality_id = get_key_locality(key);
 312         return 0;
 313 }
 314
 315 /* reiser4_inode_find_actor() - "find actor" supplied by reiser4 to iget5_locked().
 316
 317    This function is called by iget5_locked() to distinguish reiser4 inodes
 318    having the same inode numbers. Such inodes can only exist due to some error
 319    condition. One of them should be bad. Inodes with identical inode numbers
 320    (objectids) are distinguished by their packing locality.
 321
 322 */
 323 static int reiser4_inode_find_actor(struct inode *inode /* inode from hash table to
 324                                                          * check */ ,
 325                                     void *opaque        /* "cookie" passed to
 326                                                          * iget5_locked(). This is stat data
 327                                                          * key */ )
 328 {
 329         reiser4_key *key;
 330
 331         key = opaque;
 332         return
 333             /* oid is unique, so first term is enough, actually. */
 334             get_inode_oid(inode) == get_key_objectid(key) &&
 335             /*
 336              * also, locality should be checked, but locality is stored in
 337              * the reiser4-specific part of the inode, and actor can be
 338              * called against arbitrary inode that happened to be in this
 339              * hash chain. Hence we first have to check that this is
 340              * reiser4 inode at least. is_reiser4_inode() is probably too
 341              * early to call, as inode may have ->i_op not yet
 342              * initialised.
 343              */
 344             is_reiser4_super(inode->i_sb) &&
 345             /*
 346              * usually objectid is unique, but pseudo files use counter to
 347              * generate objectid. All pseudo files are placed into special
 348              * (otherwise unused) locality.
 349              */
 350             reiser4_inode_data(inode)->locality_id == get_key_locality(key);
 351 }
 352
 353 /* hook for kmem_cache_create */
 354 void loading_init_once(reiser4_inode * info)
 355 {
 356         mutex_init(&info->loading);
 357 }
 358
 359 /* for reiser4_alloc_inode */
 360 void loading_alloc(reiser4_inode * info)
 361 {
 362         assert("vs-1717", !mutex_is_locked(&info->loading));
 363 }
 364
 365 /* for reiser4_destroy */
 366 void loading_destroy(reiser4_inode * info)
 367 {
 368         assert("vs-1717a", !mutex_is_locked(&info->loading));
 369 }
 370
 371 static void loading_begin(reiser4_inode * info)
 372 {
 373         mutex_lock(&info->loading);
 374 }
 375
 376 static void loading_end(reiser4_inode * info)
 377 {
 378         mutex_unlock(&info->loading);
 379 }
 380
 381 /**
 382  * reiser4_iget - obtain inode via iget5_locked, read from disk if necessary
 383  * @super: super block of filesystem
 384  * @key: key of inode's stat-data
 385  * @silent:
 386  *
 387  * This is our helper function a la iget(). This is be called by
 388  * lookup_common() and reiser4_read_super(). Return inode locked or error
 389  * encountered.
 390  */
 391 struct inode *reiser4_iget(struct super_block *super, const reiser4_key *key,
 392                            int silent)
 393 {
 394         struct inode *inode;
 395         int result;
 396         reiser4_inode *info;
 397
 398         assert("nikita-302", super != NULL);
 399         assert("nikita-303", key != NULL);
 400
 401         result = 0;
 402
 403         /* call iget(). Our ->read_inode() is dummy, so this will either
 404            find inode in cache or return uninitialised inode */
 405         inode = iget5_locked(super,
 406                              (unsigned long)get_key_objectid(key),
 407                              reiser4_inode_find_actor,
 408                              init_locked_inode, (reiser4_key *) key);
 409         if (inode == NULL)
 410                 return ERR_PTR(RETERR(-ENOMEM));
 411         if (is_bad_inode(inode)) {
 412                 warning("nikita-304", "Bad inode found");
 413                 reiser4_print_key("key", key);
 414                 iput(inode);
 415                 return ERR_PTR(RETERR(-EIO));
 416         }
 417
 418         info = reiser4_inode_data(inode);
 419
 420         /* Reiser4 inode state bit REISER4_LOADED is used to distinguish fully
 421            loaded and initialized inode from just allocated inode. If
 422            REISER4_LOADED bit is not set, reiser4_iget() completes loading under
 423            info->loading.  The place in reiser4 which uses not initialized inode
 424            is the reiser4 repacker, see repacker-related functions in
 425            plugin/item/extent.c */
 426         if (!is_inode_loaded(inode)) {
 427                 loading_begin(info);
 428                 if (!is_inode_loaded(inode)) {
 429                         /* locking: iget5_locked returns locked inode */
 430                         assert("nikita-1941", !is_inode_loaded(inode));
 431                         assert("nikita-1949",
 432                                reiser4_inode_find_actor(inode,
 433                                                         (reiser4_key *) key));
 434                         /* now, inode has objectid as ->i_ino and locality in
 435                            reiser4-specific part. This is enough for
 436                            read_inode() to read stat data from the disk */
 437                         result = read_inode(inode, key, silent);
 438                 } else
 439                         loading_end(info);
 440         }
 441
 442         if (inode->i_state & I_NEW)
 443                 unlock_new_inode(inode);
 444
 445         if (is_bad_inode(inode)) {
 446                 assert("vs-1717", result != 0);
 447                 loading_end(info);
 448                 iput(inode);
 449                 inode = ERR_PTR(result);
 450         } else if (REISER4_DEBUG) {
 451                 reiser4_key found_key;
 452
 453                 assert("vs-1717", result == 0);
 454                 build_sd_key(inode, &found_key);
 455                 if (!keyeq(&found_key, key)) {
 456                         warning("nikita-305", "Wrong key in sd");
 457                         reiser4_print_key("sought for", key);
 458                         reiser4_print_key("found", &found_key);
 459                 }
 460                 if (inode->i_nlink == 0) {
 461                         warning("nikita-3559", "Unlinked inode found: %llu\n",
 462                                 (unsigned long long)get_inode_oid(inode));
 463                 }
 464         }
 465         return inode;
 466 }
 467
 468 /* reiser4_iget() may return not fully initialized inode, this function should
 469  * be called after one completes reiser4 inode initializing. */
 470 void reiser4_iget_complete(struct inode *inode)
 471 {
 472         assert("zam-988", is_reiser4_inode(inode));
 473
 474         if (!is_inode_loaded(inode)) {
 475                 reiser4_inode_set_flag(inode, REISER4_LOADED);
 476                 loading_end(reiser4_inode_data(inode));
 477         }
 478 }
 479
 480 void reiser4_make_bad_inode(struct inode *inode)
 481 {
 482         assert("nikita-1934", inode != NULL);
 483
 484         /* clear LOADED bit */
 485         reiser4_inode_clr_flag(inode, REISER4_LOADED);
 486         make_bad_inode(inode);
 487         return;
 488 }
 489
 490 file_plugin *inode_file_plugin(const struct inode * inode)
 491 {
 492         assert("nikita-1997", inode != NULL);
 493         return reiser4_inode_data(inode)->pset->file;
 494 }
 495
 496 dir_plugin *inode_dir_plugin(const struct inode * inode)
 497 {
 498         assert("nikita-1998", inode != NULL);
 499         return reiser4_inode_data(inode)->pset->dir;
 500 }
 501
 502 formatting_plugin *inode_formatting_plugin(const struct inode * inode)
 503 {
 504         assert("nikita-2000", inode != NULL);
 505         return reiser4_inode_data(inode)->pset->formatting;
 506 }
 507
 508 hash_plugin *inode_hash_plugin(const struct inode * inode)
 509 {
 510         assert("nikita-2001", inode != NULL);
 511         return reiser4_inode_data(inode)->pset->hash;
 512 }
 513
 514 fibration_plugin *inode_fibration_plugin(const struct inode * inode)
 515 {
 516         assert("nikita-2001", inode != NULL);
 517         return reiser4_inode_data(inode)->pset->fibration;
 518 }
 519
 520 cipher_plugin *inode_cipher_plugin(const struct inode * inode)
 521 {
 522         assert("edward-36", inode != NULL);
 523         return reiser4_inode_data(inode)->pset->cipher;
 524 }
 525
 526 compression_plugin *inode_compression_plugin(const struct inode * inode)
 527 {
 528         assert("edward-37", inode != NULL);
 529         return reiser4_inode_data(inode)->pset->compression;
 530 }
 531
 532 compression_mode_plugin *inode_compression_mode_plugin(const struct inode *
 533                                                        inode)
 534 {
 535         assert("edward-1330", inode != NULL);
 536         return reiser4_inode_data(inode)->pset->compression_mode;
 537 }
 538
 539 cluster_plugin *inode_cluster_plugin(const struct inode * inode)
 540 {
 541         assert("edward-1328", inode != NULL);
 542         return reiser4_inode_data(inode)->pset->cluster;
 543 }
 544
 545 file_plugin *inode_create_plugin(const struct inode * inode)
 546 {
 547         assert("edward-1329", inode != NULL);
 548         return reiser4_inode_data(inode)->pset->create;
 549 }
 550
 551 digest_plugin *inode_digest_plugin(const struct inode * inode)
 552 {
 553         assert("edward-86", inode != NULL);
 554         return reiser4_inode_data(inode)->pset->digest;
 555 }
 556
 557 item_plugin *inode_sd_plugin(const struct inode * inode)
 558 {
 559         assert("vs-534", inode != NULL);
 560         return reiser4_inode_data(inode)->pset->sd;
 561 }
 562
 563 item_plugin *inode_dir_item_plugin(const struct inode * inode)
 564 {
 565         assert("vs-534", inode != NULL);
 566         return reiser4_inode_data(inode)->pset->dir_item;
 567 }
 568
 569 file_plugin *child_create_plugin(const struct inode * inode)
 570 {
 571         assert("edward-1329", inode != NULL);
 572         return reiser4_inode_data(inode)->hset->create;
 573 }
 574
 575 void inode_set_extension(struct inode *inode, sd_ext_bits ext)
 576 {
 577         reiser4_inode *state;
 578
 579         assert("nikita-2716", inode != NULL);
 580         assert("nikita-2717", ext < LAST_SD_EXTENSION);
 581         assert("nikita-3491", spin_inode_is_locked(inode));
 582
 583         state = reiser4_inode_data(inode);
 584         state->extmask |= 1 << ext;
 585         /* force re-calculation of stat-data length on next call to
 586            update_sd(). */
 587         reiser4_inode_clr_flag(inode, REISER4_SDLEN_KNOWN);
 588 }
 589
 590 void inode_clr_extension(struct inode *inode, sd_ext_bits ext)
 591 {
 592         reiser4_inode *state;
 593
 594         assert("vpf-1926", inode != NULL);
 595         assert("vpf-1927", ext < LAST_SD_EXTENSION);
 596         assert("vpf-1928", spin_inode_is_locked(inode));
 597
 598         state = reiser4_inode_data(inode);
 599         state->extmask &= ~(1 << ext);
 600         /* force re-calculation of stat-data length on next call to
 601            update_sd(). */
 602         reiser4_inode_clr_flag(inode, REISER4_SDLEN_KNOWN);
 603 }
 604
 605 void inode_check_scale_nolock(struct inode *inode, __u64 old, __u64 new)
 606 {
 607         assert("edward-1287", inode != NULL);
 608         if (!dscale_fit(old, new))
 609                 reiser4_inode_clr_flag(inode, REISER4_SDLEN_KNOWN);
 610         return;
 611 }
 612
 613 void inode_check_scale(struct inode *inode, __u64 old, __u64 new)
 614 {
 615         assert("nikita-2875", inode != NULL);
 616         spin_lock_inode(inode);
 617         inode_check_scale_nolock(inode, old, new);
 618         spin_unlock_inode(inode);
 619 }
 620
 621 /*
 622  * initialize ->ordering field of inode. This field defines how file stat-data
 623  * and body is ordered within a tree with respect to other objects within the
 624  * same parent directory.
 625  */
 626 void
 627 init_inode_ordering(struct inode *inode,
 628                     reiser4_object_create_data * crd, int create)
 629 {
 630         reiser4_key key;
 631
 632         if (create) {
 633                 struct inode *parent;
 634
 635                 parent = crd->parent;
 636                 assert("nikita-3224", inode_dir_plugin(parent) != NULL);
 637                 inode_dir_plugin(parent)->build_entry_key(parent,
 638                                                           &crd->dentry->d_name,
 639                                                           &key);
 640         } else {
 641                 coord_t *coord;
 642
 643                 coord = &reiser4_inode_data(inode)->sd_coord;
 644                 coord_clear_iplug(coord);
 645                 /* safe to use ->sd_coord, because node is under long term
 646                  * lock */
 647                 WITH_DATA(coord->node, item_key_by_coord(coord, &key));
 648         }
 649
 650         set_inode_ordering(inode, get_key_ordering(&key));
 651 }
 652
 653 znode *inode_get_vroot(struct inode *inode)
 654 {
 655         reiser4_block_nr blk;
 656         znode *result;
 657
 658         spin_lock_inode(inode);
 659         blk = reiser4_inode_data(inode)->vroot;
 660         spin_unlock_inode(inode);
 661         if (!disk_addr_eq(&UBER_TREE_ADDR, &blk))
 662                 result = zlook(reiser4_tree_by_inode(inode), &blk);
 663         else
 664                 result = NULL;
 665         return result;
 666 }
 667
 668 void inode_set_vroot(struct inode *inode, znode *vroot)
 669 {
 670         spin_lock_inode(inode);
 671         reiser4_inode_data(inode)->vroot = *znode_get_block(vroot);
 672         spin_unlock_inode(inode);
 673 }
 674
 675 #if REISER4_DEBUG
 676
 677 void reiser4_inode_invariant(const struct inode *inode)
 678 {
 679         assert("nikita-3077", spin_inode_is_locked(inode));
 680 }
 681
 682 int inode_has_no_jnodes(reiser4_inode * r4_inode)
 683 {
 684         return jnode_tree_by_reiser4_inode(r4_inode)->rnode == NULL &&
 685                 r4_inode->nr_jnodes == 0;
 686 }
 687
 688 #endif
 689
 690 /* true if directory is empty (only contains dot and dotdot) */
 691 /* FIXME: shouldn't it be dir plugin method? */
 692 int is_dir_empty(const struct inode *dir)
 693 {
 694         assert("nikita-1976", dir != NULL);
 695
 696         /* rely on our method to maintain directory i_size being equal to the
 697            number of entries. */
 698         return dir->i_size <= 2 ? 0 : RETERR(-ENOTEMPTY);
 699 }
 700
 701 /* Make Linus happy.
 702    Local variables:
 703    c-indentation-style: "K&R"
 704    mode-name: "LC"
 705    c-basic-offset: 8
 706    tab-width: 8
 707    fill-column: 120
 708    End:
 709 */