src/common/fd-tracker/inode.c

   1 /*
   2  * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include <common/defaults.h>
   9 #include <common/error.h>
  10 #include <common/hashtable/utils.h>
  11 #include <common/macros.h>
  12 #include <common/optional.h>
  13 #include <common/string-utils/format.h>
  14 #include <common/utils.h>
  15 #include <inttypes.h>
  16 #include <lttng/constant.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <unistd.h>
  20 #include <urcu.h>
  21 #include <urcu/rculfhash.h>
  22 #include <urcu/ref.h>
  23
  24 #include "inode.h"
  25
  26 struct inode_id {
  27         dev_t device;
  28         ino_t inode;
  29 };
  30
  31 struct lttng_inode_registry {
  32         /* Hashtable of inode_id to lttng_inode. */
  33         struct cds_lfht *inodes;
  34 };
  35
  36 struct lttng_inode {
  37         struct inode_id id;
  38         /* Node in the lttng_inode_registry's ht. */
  39         struct cds_lfht_node registry_node;
  40         /* Weak reference to ht containing the node. */
  41         struct cds_lfht *registry_ht;
  42         struct urcu_ref ref;
  43         struct rcu_head rcu_head;
  44         /* Location from which this file can be opened. */
  45         struct {
  46                 struct lttng_directory_handle *directory_handle;
  47                 char *path;
  48         } location;
  49         /* Unlink the underlying file at the release of the inode. */
  50         bool unlink_pending;
  51         LTTNG_OPTIONAL(unsigned int) unlinked_id;
  52         /* Weak reference. */
  53         struct lttng_unlinked_file_pool *unlinked_file_pool;
  54 };
  55
  56 struct lttng_unlinked_file_pool {
  57         struct lttng_directory_handle *unlink_directory_handle;
  58         char *unlink_directory_path;
  59         unsigned int file_count;
  60         unsigned int next_id;
  61 };
  62
  63 static struct {
  64         pthread_mutex_t lock;
  65         bool initialized;
  66         unsigned long value;
  67 } seed = {
  68                 .lock = PTHREAD_MUTEX_INITIALIZER,
  69 };
  70
  71 static unsigned long lttng_inode_id_hash(const struct inode_id *id)
  72 {
  73         uint64_t device = id->device, inode_no = id->inode;
  74
  75         return hash_key_u64(&device, seed.value) ^
  76                hash_key_u64(&inode_no, seed.value);
  77 }
  78
  79 static int lttng_inode_match(struct cds_lfht_node *node, const void *key)
  80 {
  81         const struct inode_id *id = key;
  82         const struct lttng_inode *inode = caa_container_of(
  83                         node, struct lttng_inode, registry_node);
  84
  85         return inode->id.device == id->device && inode->id.inode == id->inode;
  86 }
  87
  88 static void lttng_inode_free(struct rcu_head *head)
  89 {
  90         struct lttng_inode *inode =
  91                         caa_container_of(head, struct lttng_inode, rcu_head);
  92
  93         free(inode);
  94 }
  95
  96 static int lttng_unlinked_file_pool_add_inode(
  97                 struct lttng_unlinked_file_pool *pool,
  98                 struct lttng_inode *inode)
  99 {
 100         int ret;
 101         const unsigned int unlinked_id = pool->next_id++;
 102         char *inode_unlinked_name;
 103         bool reference_acquired;
 104
 105         DBG("Adding inode of %s to unlinked file pool as id %u",
 106                         inode->location.path, unlinked_id);
 107         ret = asprintf(&inode_unlinked_name, "%u", unlinked_id);
 108         if (ret < 0) {
 109                 ERR("Failed to format unlinked inode name");
 110                 ret = -1;
 111                 goto end;
 112         }
 113
 114         if (pool->file_count == 0) {
 115                 DBG("Creating unlinked files directory at %s",
 116                                 pool->unlink_directory_path);
 117                 assert(!pool->unlink_directory_handle);
 118                 ret = utils_mkdir(pool->unlink_directory_path,
 119                                 S_IRWXU | S_IRWXG, -1, -1);
 120                 if (ret) {
 121                         if (errno == EEXIST) {
 122                                 /*
 123                                  * Unexpected (previous crash?), but not an
 124                                  * error.
 125                                  */
 126                                 DBG("Unlinked file directory \"%s\" already exists",
 127                                                 pool->unlink_directory_path);
 128                         } else {
 129                                 PERROR("Failed to create unlinked files directory at %s",
 130                                                 pool->unlink_directory_path);
 131                                 goto end;
 132                         }
 133                 }
 134                 pool->unlink_directory_handle = lttng_directory_handle_create(
 135                                 pool->unlink_directory_path);
 136                 if (!pool->unlink_directory_handle) {
 137                         ERR("Failed to create directory handle to unlinked file pool at %s",
 138                                         pool->unlink_directory_path);
 139                         ret = -1;
 140                         goto end;
 141                 }
 142         }
 143
 144         ret = lttng_directory_handle_rename(inode->location.directory_handle,
 145                         inode->location.path, pool->unlink_directory_handle,
 146                         inode_unlinked_name);
 147         if (ret) {
 148                 goto end;
 149         }
 150
 151         lttng_directory_handle_put(inode->location.directory_handle);
 152         inode->location.directory_handle = NULL;
 153         reference_acquired = lttng_directory_handle_get(
 154                         pool->unlink_directory_handle);
 155         assert(reference_acquired);
 156         inode->location.directory_handle = pool->unlink_directory_handle;
 157
 158         free(inode->location.path);
 159         inode->location.path = inode_unlinked_name;
 160         inode_unlinked_name = NULL;
 161         LTTNG_OPTIONAL_SET(&inode->unlinked_id, unlinked_id);
 162         pool->file_count++;
 163 end:
 164         free(inode_unlinked_name);
 165         return ret;
 166 }
 167
 168 static int lttng_unlinked_file_pool_remove_inode(
 169                 struct lttng_unlinked_file_pool *pool,
 170                 struct lttng_inode *inode)
 171 {
 172         int ret;
 173
 174         DBG("Removing inode with unlinked id %u from unlinked file pool",
 175                         LTTNG_OPTIONAL_GET(inode->unlinked_id));
 176
 177         ret = lttng_directory_handle_unlink_file(
 178                         inode->location.directory_handle, inode->location.path);
 179         if (ret) {
 180                 PERROR("Failed to unlink file %s from unlinked file directory",
 181                                 inode->location.path);
 182                 goto end;
 183         }
 184         free(inode->location.path);
 185         inode->location.path = NULL;
 186         lttng_directory_handle_put(inode->location.directory_handle);
 187         inode->location.directory_handle = NULL;
 188
 189         pool->file_count--;
 190         if (pool->file_count == 0) {
 191                 ret = utils_recursive_rmdir(pool->unlink_directory_path);
 192                 if (ret) {
 193                         /*
 194                          * There is nothing the caller can do, don't report an
 195                          * error except through logging.
 196                          */
 197                         PERROR("Failed to remove unlinked files directory at %s",
 198                                         pool->unlink_directory_path);
 199                 }
 200                 lttng_directory_handle_put(pool->unlink_directory_handle);
 201                 pool->unlink_directory_handle = NULL;
 202         }
 203 end:
 204         return ret;
 205 }
 206
 207 static void lttng_inode_destroy(struct lttng_inode *inode)
 208 {
 209         if (!inode) {
 210                 return;
 211         }
 212
 213         rcu_read_lock();
 214         cds_lfht_del(inode->registry_ht, &inode->registry_node);
 215         rcu_read_unlock();
 216
 217         if (inode->unlink_pending) {
 218                 int ret;
 219
 220                 assert(inode->location.directory_handle);
 221                 assert(inode->location.path);
 222                 DBG("Removing %s from unlinked file pool",
 223                                 inode->location.path);
 224                 ret = lttng_unlinked_file_pool_remove_inode(inode->unlinked_file_pool, inode);
 225                 if (ret) {
 226                         PERROR("Failed to unlink %s", inode->location.path);
 227                 }
 228         }
 229
 230         lttng_directory_handle_put(
 231                         inode->location.directory_handle);
 232         inode->location.directory_handle = NULL;
 233         free(inode->location.path);
 234         inode->location.path = NULL;
 235         call_rcu(&inode->rcu_head, lttng_inode_free);
 236 }
 237
 238 static void lttng_inode_release(struct urcu_ref *ref)
 239 {
 240         lttng_inode_destroy(caa_container_of(ref, struct lttng_inode, ref));
 241 }
 242
 243 static void lttng_inode_get(struct lttng_inode *inode)
 244 {
 245         urcu_ref_get(&inode->ref);
 246 }
 247
 248 LTTNG_HIDDEN struct lttng_unlinked_file_pool *lttng_unlinked_file_pool_create(
 249                 const char *path)
 250 {
 251         struct lttng_unlinked_file_pool *pool = zmalloc(sizeof(*pool));
 252
 253         if (!path || *path != '/') {
 254                 ERR("Unlinked file pool must be created with an absolute path, path = \"%s\"",
 255                                 path ? path : "NULL");
 256                 goto error;
 257         }
 258
 259         pool->unlink_directory_path = strdup(path);
 260         if (!pool->unlink_directory_path) {
 261                 PERROR("Failed to allocation unlinked file pool path");
 262                 goto error;
 263         }
 264         DBG("Unlinked file pool created at: %s", path);
 265         return pool;
 266 error:
 267         lttng_unlinked_file_pool_destroy(pool);
 268         return NULL;
 269 }
 270
 271 LTTNG_HIDDEN void lttng_unlinked_file_pool_destroy(
 272                 struct lttng_unlinked_file_pool *pool)
 273 {
 274         if (!pool) {
 275                 return;
 276         }
 277
 278         assert(pool->file_count == 0);
 279         lttng_directory_handle_put(pool->unlink_directory_handle);
 280         free(pool->unlink_directory_path);
 281         free(pool);
 282 }
 283
 284 LTTNG_HIDDEN void lttng_inode_put(struct lttng_inode *inode)
 285 {
 286         urcu_ref_put(&inode->ref, lttng_inode_release);
 287 }
 288
 289 LTTNG_HIDDEN struct lttng_directory_handle *
 290 lttng_inode_get_location_directory_handle(
 291                 struct lttng_inode *inode)
 292 {
 293         if (inode->location.directory_handle) {
 294                 const bool reference_acquired = lttng_directory_handle_get(
 295                                 inode->location.directory_handle);
 296
 297                 assert(reference_acquired);
 298         }
 299         return inode->location.directory_handle;
 300 }
 301
 302 LTTNG_HIDDEN void lttng_inode_borrow_location(struct lttng_inode *inode,
 303                 const struct lttng_directory_handle **out_directory_handle,
 304                 const char **out_path)
 305 {
 306         if (out_directory_handle) {
 307                 *out_directory_handle = inode->location.directory_handle;
 308         }
 309         if (out_path) {
 310                 *out_path = inode->location.path;
 311         }
 312 }
 313
 314 LTTNG_HIDDEN int lttng_inode_rename(
 315                 struct lttng_inode *inode,
 316                 struct lttng_directory_handle *old_directory_handle,
 317                 const char *old_path,
 318                 struct lttng_directory_handle *new_directory_handle,
 319                 const char *new_path,
 320                 bool overwrite)
 321 {
 322         int ret = 0;
 323         char *new_path_copy = strdup(new_path);
 324         bool reference_acquired;
 325
 326         DBG("Performing rename of inode from %s to %s with %s directory handles",
 327                         old_path, new_path,
 328                         lttng_directory_handle_equals(old_directory_handle,
 329                                         new_directory_handle) ?
 330                                         "identical" :
 331                                         "different");
 332
 333         if (!new_path_copy) {
 334                 ret = -ENOMEM;
 335                 goto end;
 336         }
 337
 338         if (inode->unlink_pending) {
 339                 WARN("An attempt to rename an unlinked file from %s to %s has been performed",
 340                                 old_path, new_path);
 341                 ret = -ENOENT;
 342                 goto end;
 343         }
 344
 345         if (!overwrite) {
 346                 /* Verify that file doesn't exist. */
 347                 struct stat statbuf;
 348
 349                 ret = lttng_directory_handle_stat(
 350                                 new_directory_handle, new_path, &statbuf);
 351                 if (ret == 0) {
 352                         ERR("Refusing to rename %s as the destination already exists",
 353                                         old_path);
 354                         ret = -EEXIST;
 355                         goto end;
 356                 } else if (ret < 0 && errno != ENOENT) {
 357                         PERROR("Failed to stat() %s", new_path);
 358                         ret = -errno;
 359                         goto end;
 360                 }
 361         }
 362
 363         ret = lttng_directory_handle_rename(old_directory_handle, old_path,
 364                         new_directory_handle, new_path);
 365         if (ret) {
 366                 PERROR("Failed to rename file %s to %s", old_path, new_path);
 367                 ret = -errno;
 368                 goto end;
 369         }
 370
 371         reference_acquired = lttng_directory_handle_get(new_directory_handle);
 372         assert(reference_acquired);
 373         lttng_directory_handle_put(inode->location.directory_handle);
 374         free(inode->location.path);
 375         inode->location.directory_handle = new_directory_handle;
 376         /* Ownership transferred. */
 377         inode->location.path = new_path_copy;
 378         new_path_copy = NULL;
 379 end:
 380         free(new_path_copy);
 381         return ret;
 382 }
 383
 384 LTTNG_HIDDEN int lttng_inode_unlink(struct lttng_inode *inode)
 385 {
 386         int ret = 0;
 387
 388         DBG("Attempting unlink of inode %s", inode->location.path);
 389
 390         if (inode->unlink_pending) {
 391                 WARN("An attempt to re-unlink %s has been performed, ignoring.",
 392                                 inode->location.path);
 393                 ret = -ENOENT;
 394                 goto end;
 395         }
 396
 397         /*
 398          * Move to the temporary "deleted" directory until all
 399          * references are released.
 400          */
 401         ret = lttng_unlinked_file_pool_add_inode(
 402                         inode->unlinked_file_pool, inode);
 403         if (ret) {
 404                 PERROR("Failed to add inode \"%s\" to the unlinked file pool",
 405                                 inode->location.path);
 406                 goto end;
 407         }
 408         inode->unlink_pending = true;
 409 end:
 410         return ret;
 411 }
 412
 413 static struct lttng_inode *lttng_inode_create(const struct inode_id *id,
 414                 struct cds_lfht *ht,
 415                 struct lttng_unlinked_file_pool *unlinked_file_pool,
 416                 struct lttng_directory_handle *directory_handle,
 417                 const char *path)
 418 {
 419         struct lttng_inode *inode = NULL;
 420         char *path_copy;
 421         bool reference_acquired;
 422
 423         path_copy = strdup(path);
 424         if (!path_copy) {
 425                 goto end;
 426         }
 427
 428         reference_acquired = lttng_directory_handle_get(directory_handle);
 429         assert(reference_acquired);
 430
 431         inode = zmalloc(sizeof(*inode));
 432         if (!inode) {
 433                 goto end;
 434         }
 435
 436         urcu_ref_init(&inode->ref);
 437         cds_lfht_node_init(&inode->registry_node);
 438         inode->id = *id;
 439         inode->registry_ht = ht;
 440         inode->unlinked_file_pool = unlinked_file_pool;
 441         /* Ownership of path copy is transferred to inode. */
 442         inode->location.path = path_copy;
 443         path_copy = NULL;
 444         inode->location.directory_handle = directory_handle;
 445 end:
 446         free(path_copy);
 447         return inode;
 448 }
 449
 450 LTTNG_HIDDEN struct lttng_inode_registry *lttng_inode_registry_create(void)
 451 {
 452         struct lttng_inode_registry *registry = zmalloc(sizeof(*registry));
 453
 454         if (!registry) {
 455                 goto end;
 456         }
 457
 458         pthread_mutex_lock(&seed.lock);
 459         if (!seed.initialized) {
 460                 seed.value = (unsigned long) time(NULL);
 461                 seed.initialized = true;
 462         }
 463         pthread_mutex_unlock(&seed.lock);
 464
 465         registry->inodes = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
 466                         CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
 467         if (!registry->inodes) {
 468                 goto error;
 469         }
 470 end:
 471         return registry;
 472 error:
 473         lttng_inode_registry_destroy(registry);
 474         return NULL;
 475 }
 476
 477 LTTNG_HIDDEN void lttng_inode_registry_destroy(
 478                 struct lttng_inode_registry *registry)
 479 {
 480         if (!registry) {
 481                 return;
 482         }
 483         if (registry->inodes) {
 484                 int ret = cds_lfht_destroy(registry->inodes, NULL);
 485
 486                 assert(!ret);
 487         }
 488         free(registry);
 489 }
 490
 491 LTTNG_HIDDEN struct lttng_inode *lttng_inode_registry_get_inode(
 492                 struct lttng_inode_registry *registry,
 493                 struct lttng_directory_handle *handle,
 494                 const char *path,
 495                 int fd,
 496                 struct lttng_unlinked_file_pool *unlinked_file_pool)
 497 {
 498         int ret;
 499         struct stat statbuf;
 500         struct inode_id id;
 501         struct cds_lfht_iter iter;
 502         struct cds_lfht_node *node;
 503         struct lttng_inode *inode = NULL;
 504
 505         ret = fstat(fd, &statbuf);
 506         if (ret < 0) {
 507                 PERROR("stat() failed on fd %i", fd);
 508                 goto end;
 509         }
 510
 511         id.device = statbuf.st_dev;
 512         id.inode = statbuf.st_ino;
 513
 514         rcu_read_lock();
 515         cds_lfht_lookup(registry->inodes, lttng_inode_id_hash(&id),
 516                         lttng_inode_match, &id, &iter);
 517         node = cds_lfht_iter_get_node(&iter);
 518         if (node) {
 519                 inode = caa_container_of(
 520                                 node, struct lttng_inode, registry_node);
 521                 lttng_inode_get(inode);
 522                 goto end_unlock;
 523         }
 524
 525         inode = lttng_inode_create(&id, registry->inodes, unlinked_file_pool,
 526                         handle, path);
 527         if (!inode) {
 528                 goto end_unlock;
 529         }
 530
 531         node = cds_lfht_add_unique(registry->inodes,
 532                         lttng_inode_id_hash(&inode->id), lttng_inode_match,
 533                         &inode->id, &inode->registry_node);
 534         assert(node == &inode->registry_node);
 535 end_unlock:
 536         rcu_read_unlock();
 537 end:
 538         return inode;
 539 }