mm/damon/dbgfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * DAMON Debugfs Interface
   4  *
   5  * Author: SeongJae Park <sj@kernel.org>
   6  */
   7
   8 #define pr_fmt(fmt) "damon-dbgfs: " fmt
   9
  10 #include <linux/damon.h>
  11 #include <linux/debugfs.h>
  12 #include <linux/file.h>
  13 #include <linux/mm.h>
  14 #include <linux/module.h>
  15 #include <linux/page_idle.h>
  16 #include <linux/slab.h>
  17
  18 #define DAMON_DBGFS_DEPRECATION_NOTICE                                  \
  19         "DAMON debugfs interface is deprecated, so users should move "  \
  20         "to DAMON_SYSFS. If you cannot, please report your usecase to " \
  21         "damon@lists.linux.dev and linux-mm@kvack.org.\n"
  22
  23 static struct damon_ctx **dbgfs_ctxs;
  24 static int dbgfs_nr_ctxs;
  25 static struct dentry **dbgfs_dirs;
  26 static DEFINE_MUTEX(damon_dbgfs_lock);
  27
  28 static void damon_dbgfs_warn_deprecation(void)
  29 {
  30         pr_warn_once(DAMON_DBGFS_DEPRECATION_NOTICE);
  31 }
  32
  33 /*
  34  * Returns non-empty string on success, negative error code otherwise.
  35  */
  36 static char *user_input_str(const char __user *buf, size_t count, loff_t *ppos)
  37 {
  38         char *kbuf;
  39         ssize_t ret;
  40
  41         /* We do not accept continuous write */
  42         if (*ppos)
  43                 return ERR_PTR(-EINVAL);
  44
  45         kbuf = kmalloc(count + 1, GFP_KERNEL | __GFP_NOWARN);
  46         if (!kbuf)
  47                 return ERR_PTR(-ENOMEM);
  48
  49         ret = simple_write_to_buffer(kbuf, count + 1, ppos, buf, count);
  50         if (ret != count) {
  51                 kfree(kbuf);
  52                 return ERR_PTR(-EIO);
  53         }
  54         kbuf[ret] = '\0';
  55
  56         return kbuf;
  57 }
  58
  59 static ssize_t dbgfs_attrs_read(struct file *file,
  60                 char __user *buf, size_t count, loff_t *ppos)
  61 {
  62         struct damon_ctx *ctx = file->private_data;
  63         char kbuf[128];
  64         int ret;
  65
  66         mutex_lock(&ctx->kdamond_lock);
  67         ret = scnprintf(kbuf, ARRAY_SIZE(kbuf), "%lu %lu %lu %lu %lu\n",
  68                         ctx->attrs.sample_interval, ctx->attrs.aggr_interval,
  69                         ctx->attrs.ops_update_interval,
  70                         ctx->attrs.min_nr_regions, ctx->attrs.max_nr_regions);
  71         mutex_unlock(&ctx->kdamond_lock);
  72
  73         return simple_read_from_buffer(buf, count, ppos, kbuf, ret);
  74 }
  75
  76 static ssize_t dbgfs_attrs_write(struct file *file,
  77                 const char __user *buf, size_t count, loff_t *ppos)
  78 {
  79         struct damon_ctx *ctx = file->private_data;
  80         struct damon_attrs attrs;
  81         char *kbuf;
  82         ssize_t ret;
  83
  84         kbuf = user_input_str(buf, count, ppos);
  85         if (IS_ERR(kbuf))
  86                 return PTR_ERR(kbuf);
  87
  88         if (sscanf(kbuf, "%lu %lu %lu %lu %lu",
  89                                 &attrs.sample_interval, &attrs.aggr_interval,
  90                                 &attrs.ops_update_interval,
  91                                 &attrs.min_nr_regions,
  92                                 &attrs.max_nr_regions) != 5) {
  93                 ret = -EINVAL;
  94                 goto out;
  95         }
  96
  97         mutex_lock(&ctx->kdamond_lock);
  98         if (ctx->kdamond) {
  99                 ret = -EBUSY;
 100                 goto unlock_out;
 101         }
 102
 103         ret = damon_set_attrs(ctx, &attrs);
 104         if (!ret)
 105                 ret = count;
 106 unlock_out:
 107         mutex_unlock(&ctx->kdamond_lock);
 108 out:
 109         kfree(kbuf);
 110         return ret;
 111 }
 112
 113 /*
 114  * Return corresponding dbgfs' scheme action value (int) for the given
 115  * damos_action if the given damos_action value is valid and supported by
 116  * dbgfs, negative error code otherwise.
 117  */
 118 static int damos_action_to_dbgfs_scheme_action(enum damos_action action)
 119 {
 120         switch (action) {
 121         case DAMOS_WILLNEED:
 122                 return 0;
 123         case DAMOS_COLD:
 124                 return 1;
 125         case DAMOS_PAGEOUT:
 126                 return 2;
 127         case DAMOS_HUGEPAGE:
 128                 return 3;
 129         case DAMOS_NOHUGEPAGE:
 130                 return 4;
 131         case DAMOS_STAT:
 132                 return 5;
 133         default:
 134                 return -EINVAL;
 135         }
 136 }
 137
 138 static ssize_t sprint_schemes(struct damon_ctx *c, char *buf, ssize_t len)
 139 {
 140         struct damos *s;
 141         int written = 0;
 142         int rc;
 143
 144         damon_for_each_scheme(s, c) {
 145                 rc = scnprintf(&buf[written], len - written,
 146                                 "%lu %lu %u %u %u %u %d %lu %lu %lu %u %u %u %d %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
 147                                 s->pattern.min_sz_region,
 148                                 s->pattern.max_sz_region,
 149                                 s->pattern.min_nr_accesses,
 150                                 s->pattern.max_nr_accesses,
 151                                 s->pattern.min_age_region,
 152                                 s->pattern.max_age_region,
 153                                 damos_action_to_dbgfs_scheme_action(s->action),
 154                                 s->quota.ms, s->quota.sz,
 155                                 s->quota.reset_interval,
 156                                 s->quota.weight_sz,
 157                                 s->quota.weight_nr_accesses,
 158                                 s->quota.weight_age,
 159                                 s->wmarks.metric, s->wmarks.interval,
 160                                 s->wmarks.high, s->wmarks.mid, s->wmarks.low,
 161                                 s->stat.nr_tried, s->stat.sz_tried,
 162                                 s->stat.nr_applied, s->stat.sz_applied,
 163                                 s->stat.qt_exceeds);
 164                 if (!rc)
 165                         return -ENOMEM;
 166
 167                 written += rc;
 168         }
 169         return written;
 170 }
 171
 172 static ssize_t dbgfs_schemes_read(struct file *file, char __user *buf,
 173                 size_t count, loff_t *ppos)
 174 {
 175         struct damon_ctx *ctx = file->private_data;
 176         char *kbuf;
 177         ssize_t len;
 178
 179         kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
 180         if (!kbuf)
 181                 return -ENOMEM;
 182
 183         mutex_lock(&ctx->kdamond_lock);
 184         len = sprint_schemes(ctx, kbuf, count);
 185         mutex_unlock(&ctx->kdamond_lock);
 186         if (len < 0)
 187                 goto out;
 188         len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
 189
 190 out:
 191         kfree(kbuf);
 192         return len;
 193 }
 194
 195 static void free_schemes_arr(struct damos **schemes, ssize_t nr_schemes)
 196 {
 197         ssize_t i;
 198
 199         for (i = 0; i < nr_schemes; i++)
 200                 kfree(schemes[i]);
 201         kfree(schemes);
 202 }
 203
 204 /*
 205  * Return corresponding damos_action for the given dbgfs input for a scheme
 206  * action if the input is valid, negative error code otherwise.
 207  */
 208 static enum damos_action dbgfs_scheme_action_to_damos_action(int dbgfs_action)
 209 {
 210         switch (dbgfs_action) {
 211         case 0:
 212                 return DAMOS_WILLNEED;
 213         case 1:
 214                 return DAMOS_COLD;
 215         case 2:
 216                 return DAMOS_PAGEOUT;
 217         case 3:
 218                 return DAMOS_HUGEPAGE;
 219         case 4:
 220                 return DAMOS_NOHUGEPAGE;
 221         case 5:
 222                 return DAMOS_STAT;
 223         default:
 224                 return -EINVAL;
 225         }
 226 }
 227
 228 /*
 229  * Converts a string into an array of struct damos pointers
 230  *
 231  * Returns an array of struct damos pointers that converted if the conversion
 232  * success, or NULL otherwise.
 233  */
 234 static struct damos **str_to_schemes(const char *str, ssize_t len,
 235                                 ssize_t *nr_schemes)
 236 {
 237         struct damos *scheme, **schemes;
 238         const int max_nr_schemes = 256;
 239         int pos = 0, parsed, ret;
 240         unsigned int action_input;
 241         enum damos_action action;
 242
 243         schemes = kmalloc_array(max_nr_schemes, sizeof(scheme),
 244                         GFP_KERNEL);
 245         if (!schemes)
 246                 return NULL;
 247
 248         *nr_schemes = 0;
 249         while (pos < len && *nr_schemes < max_nr_schemes) {
 250                 struct damos_access_pattern pattern = {};
 251                 struct damos_quota quota = {};
 252                 struct damos_watermarks wmarks;
 253
 254                 ret = sscanf(&str[pos],
 255                                 "%lu %lu %u %u %u %u %u %lu %lu %lu %u %u %u %u %lu %lu %lu %lu%n",
 256                                 &pattern.min_sz_region, &pattern.max_sz_region,
 257                                 &pattern.min_nr_accesses,
 258                                 &pattern.max_nr_accesses,
 259                                 &pattern.min_age_region,
 260                                 &pattern.max_age_region,
 261                                 &action_input, &quota.ms,
 262                                 &quota.sz, &quota.reset_interval,
 263                                 &quota.weight_sz, &quota.weight_nr_accesses,
 264                                 &quota.weight_age, &wmarks.metric,
 265                                 &wmarks.interval, &wmarks.high, &wmarks.mid,
 266                                 &wmarks.low, &parsed);
 267                 if (ret != 18)
 268                         break;
 269                 action = dbgfs_scheme_action_to_damos_action(action_input);
 270                 if ((int)action < 0)
 271                         goto fail;
 272
 273                 if (pattern.min_sz_region > pattern.max_sz_region ||
 274                     pattern.min_nr_accesses > pattern.max_nr_accesses ||
 275                     pattern.min_age_region > pattern.max_age_region)
 276                         goto fail;
 277
 278                 if (wmarks.high < wmarks.mid || wmarks.high < wmarks.low ||
 279                     wmarks.mid <  wmarks.low)
 280                         goto fail;
 281
 282                 pos += parsed;
 283                 scheme = damon_new_scheme(&pattern, action, 0, &quota,
 284                                 &wmarks, NUMA_NO_NODE);
 285                 if (!scheme)
 286                         goto fail;
 287
 288                 schemes[*nr_schemes] = scheme;
 289                 *nr_schemes += 1;
 290         }
 291         return schemes;
 292 fail:
 293         free_schemes_arr(schemes, *nr_schemes);
 294         return NULL;
 295 }
 296
 297 static ssize_t dbgfs_schemes_write(struct file *file, const char __user *buf,
 298                 size_t count, loff_t *ppos)
 299 {
 300         struct damon_ctx *ctx = file->private_data;
 301         char *kbuf;
 302         struct damos **schemes;
 303         ssize_t nr_schemes = 0, ret;
 304
 305         kbuf = user_input_str(buf, count, ppos);
 306         if (IS_ERR(kbuf))
 307                 return PTR_ERR(kbuf);
 308
 309         schemes = str_to_schemes(kbuf, count, &nr_schemes);
 310         if (!schemes) {
 311                 ret = -EINVAL;
 312                 goto out;
 313         }
 314
 315         mutex_lock(&ctx->kdamond_lock);
 316         if (ctx->kdamond) {
 317                 ret = -EBUSY;
 318                 goto unlock_out;
 319         }
 320
 321         damon_set_schemes(ctx, schemes, nr_schemes);
 322         ret = count;
 323         nr_schemes = 0;
 324
 325 unlock_out:
 326         mutex_unlock(&ctx->kdamond_lock);
 327         free_schemes_arr(schemes, nr_schemes);
 328 out:
 329         kfree(kbuf);
 330         return ret;
 331 }
 332
 333 static ssize_t sprint_target_ids(struct damon_ctx *ctx, char *buf, ssize_t len)
 334 {
 335         struct damon_target *t;
 336         int id;
 337         int written = 0;
 338         int rc;
 339
 340         damon_for_each_target(t, ctx) {
 341                 if (damon_target_has_pid(ctx))
 342                         /* Show pid numbers to debugfs users */
 343                         id = pid_vnr(t->pid);
 344                 else
 345                         /* Show 42 for physical address space, just for fun */
 346                         id = 42;
 347
 348                 rc = scnprintf(&buf[written], len - written, "%d ", id);
 349                 if (!rc)
 350                         return -ENOMEM;
 351                 written += rc;
 352         }
 353         if (written)
 354                 written -= 1;
 355         written += scnprintf(&buf[written], len - written, "\n");
 356         return written;
 357 }
 358
 359 static ssize_t dbgfs_target_ids_read(struct file *file,
 360                 char __user *buf, size_t count, loff_t *ppos)
 361 {
 362         struct damon_ctx *ctx = file->private_data;
 363         ssize_t len;
 364         char ids_buf[320];
 365
 366         mutex_lock(&ctx->kdamond_lock);
 367         len = sprint_target_ids(ctx, ids_buf, 320);
 368         mutex_unlock(&ctx->kdamond_lock);
 369         if (len < 0)
 370                 return len;
 371
 372         return simple_read_from_buffer(buf, count, ppos, ids_buf, len);
 373 }
 374
 375 /*
 376  * Converts a string into an integers array
 377  *
 378  * Returns an array of integers array if the conversion success, or NULL
 379  * otherwise.
 380  */
 381 static int *str_to_ints(const char *str, ssize_t len, ssize_t *nr_ints)
 382 {
 383         int *array;
 384         const int max_nr_ints = 32;
 385         int nr;
 386         int pos = 0, parsed, ret;
 387
 388         *nr_ints = 0;
 389         array = kmalloc_array(max_nr_ints, sizeof(*array), GFP_KERNEL);
 390         if (!array)
 391                 return NULL;
 392         while (*nr_ints < max_nr_ints && pos < len) {
 393                 ret = sscanf(&str[pos], "%d%n", &nr, &parsed);
 394                 pos += parsed;
 395                 if (ret != 1)
 396                         break;
 397                 array[*nr_ints] = nr;
 398                 *nr_ints += 1;
 399         }
 400
 401         return array;
 402 }
 403
 404 static void dbgfs_put_pids(struct pid **pids, int nr_pids)
 405 {
 406         int i;
 407
 408         for (i = 0; i < nr_pids; i++)
 409                 put_pid(pids[i]);
 410 }
 411
 412 /*
 413  * Converts a string into an struct pid pointers array
 414  *
 415  * Returns an array of struct pid pointers if the conversion success, or NULL
 416  * otherwise.
 417  */
 418 static struct pid **str_to_pids(const char *str, ssize_t len, ssize_t *nr_pids)
 419 {
 420         int *ints;
 421         ssize_t nr_ints;
 422         struct pid **pids;
 423
 424         *nr_pids = 0;
 425
 426         ints = str_to_ints(str, len, &nr_ints);
 427         if (!ints)
 428                 return NULL;
 429
 430         pids = kmalloc_array(nr_ints, sizeof(*pids), GFP_KERNEL);
 431         if (!pids)
 432                 goto out;
 433
 434         for (; *nr_pids < nr_ints; (*nr_pids)++) {
 435                 pids[*nr_pids] = find_get_pid(ints[*nr_pids]);
 436                 if (!pids[*nr_pids]) {
 437                         dbgfs_put_pids(pids, *nr_pids);
 438                         kfree(ints);
 439                         kfree(pids);
 440                         return NULL;
 441                 }
 442         }
 443
 444 out:
 445         kfree(ints);
 446         return pids;
 447 }
 448
 449 /*
 450  * dbgfs_set_targets() - Set monitoring targets.
 451  * @ctx:        monitoring context
 452  * @nr_targets: number of targets
 453  * @pids:       array of target pids (size is same to @nr_targets)
 454  *
 455  * This function should not be called while the kdamond is running.  @pids is
 456  * ignored if the context is not configured to have pid in each target.  On
 457  * failure, reference counts of all pids in @pids are decremented.
 458  *
 459  * Return: 0 on success, negative error code otherwise.
 460  */
 461 static int dbgfs_set_targets(struct damon_ctx *ctx, ssize_t nr_targets,
 462                 struct pid **pids)
 463 {
 464         ssize_t i;
 465         struct damon_target *t, *next;
 466
 467         damon_for_each_target_safe(t, next, ctx) {
 468                 if (damon_target_has_pid(ctx))
 469                         put_pid(t->pid);
 470                 damon_destroy_target(t);
 471         }
 472
 473         for (i = 0; i < nr_targets; i++) {
 474                 t = damon_new_target();
 475                 if (!t) {
 476                         damon_for_each_target_safe(t, next, ctx)
 477                                 damon_destroy_target(t);
 478                         if (damon_target_has_pid(ctx))
 479                                 dbgfs_put_pids(pids, nr_targets);
 480                         return -ENOMEM;
 481                 }
 482                 if (damon_target_has_pid(ctx))
 483                         t->pid = pids[i];
 484                 damon_add_target(ctx, t);
 485         }
 486
 487         return 0;
 488 }
 489
 490 static ssize_t dbgfs_target_ids_write(struct file *file,
 491                 const char __user *buf, size_t count, loff_t *ppos)
 492 {
 493         struct damon_ctx *ctx = file->private_data;
 494         bool id_is_pid = true;
 495         char *kbuf;
 496         struct pid **target_pids = NULL;
 497         ssize_t nr_targets;
 498         ssize_t ret;
 499
 500         kbuf = user_input_str(buf, count, ppos);
 501         if (IS_ERR(kbuf))
 502                 return PTR_ERR(kbuf);
 503
 504         if (!strncmp(kbuf, "paddr\n", count)) {
 505                 id_is_pid = false;
 506                 nr_targets = 1;
 507         }
 508
 509         if (id_is_pid) {
 510                 target_pids = str_to_pids(kbuf, count, &nr_targets);
 511                 if (!target_pids) {
 512                         ret = -ENOMEM;
 513                         goto out;
 514                 }
 515         }
 516
 517         mutex_lock(&ctx->kdamond_lock);
 518         if (ctx->kdamond) {
 519                 if (id_is_pid)
 520                         dbgfs_put_pids(target_pids, nr_targets);
 521                 ret = -EBUSY;
 522                 goto unlock_out;
 523         }
 524
 525         /* remove previously set targets */
 526         dbgfs_set_targets(ctx, 0, NULL);
 527         if (!nr_targets) {
 528                 ret = count;
 529                 goto unlock_out;
 530         }
 531
 532         /* Configure the context for the address space type */
 533         if (id_is_pid)
 534                 ret = damon_select_ops(ctx, DAMON_OPS_VADDR);
 535         else
 536                 ret = damon_select_ops(ctx, DAMON_OPS_PADDR);
 537         if (ret)
 538                 goto unlock_out;
 539
 540         ret = dbgfs_set_targets(ctx, nr_targets, target_pids);
 541         if (!ret)
 542                 ret = count;
 543
 544 unlock_out:
 545         mutex_unlock(&ctx->kdamond_lock);
 546         kfree(target_pids);
 547 out:
 548         kfree(kbuf);
 549         return ret;
 550 }
 551
 552 static ssize_t sprint_init_regions(struct damon_ctx *c, char *buf, ssize_t len)
 553 {
 554         struct damon_target *t;
 555         struct damon_region *r;
 556         int target_idx = 0;
 557         int written = 0;
 558         int rc;
 559
 560         damon_for_each_target(t, c) {
 561                 damon_for_each_region(r, t) {
 562                         rc = scnprintf(&buf[written], len - written,
 563                                         "%d %lu %lu\n",
 564                                         target_idx, r->ar.start, r->ar.end);
 565                         if (!rc)
 566                                 return -ENOMEM;
 567                         written += rc;
 568                 }
 569                 target_idx++;
 570         }
 571         return written;
 572 }
 573
 574 static ssize_t dbgfs_init_regions_read(struct file *file, char __user *buf,
 575                 size_t count, loff_t *ppos)
 576 {
 577         struct damon_ctx *ctx = file->private_data;
 578         char *kbuf;
 579         ssize_t len;
 580
 581         kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
 582         if (!kbuf)
 583                 return -ENOMEM;
 584
 585         mutex_lock(&ctx->kdamond_lock);
 586         if (ctx->kdamond) {
 587                 mutex_unlock(&ctx->kdamond_lock);
 588                 len = -EBUSY;
 589                 goto out;
 590         }
 591
 592         len = sprint_init_regions(ctx, kbuf, count);
 593         mutex_unlock(&ctx->kdamond_lock);
 594         if (len < 0)
 595                 goto out;
 596         len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
 597
 598 out:
 599         kfree(kbuf);
 600         return len;
 601 }
 602
 603 static int add_init_region(struct damon_ctx *c, int target_idx,
 604                 struct damon_addr_range *ar)
 605 {
 606         struct damon_target *t;
 607         struct damon_region *r, *prev;
 608         unsigned long idx = 0;
 609         int rc = -EINVAL;
 610
 611         if (ar->start >= ar->end)
 612                 return -EINVAL;
 613
 614         damon_for_each_target(t, c) {
 615                 if (idx++ == target_idx) {
 616                         r = damon_new_region(ar->start, ar->end);
 617                         if (!r)
 618                                 return -ENOMEM;
 619                         damon_add_region(r, t);
 620                         if (damon_nr_regions(t) > 1) {
 621                                 prev = damon_prev_region(r);
 622                                 if (prev->ar.end > r->ar.start) {
 623                                         damon_destroy_region(r, t);
 624                                         return -EINVAL;
 625                                 }
 626                         }
 627                         rc = 0;
 628                 }
 629         }
 630         return rc;
 631 }
 632
 633 static int set_init_regions(struct damon_ctx *c, const char *str, ssize_t len)
 634 {
 635         struct damon_target *t;
 636         struct damon_region *r, *next;
 637         int pos = 0, parsed, ret;
 638         int target_idx;
 639         struct damon_addr_range ar;
 640         int err;
 641
 642         damon_for_each_target(t, c) {
 643                 damon_for_each_region_safe(r, next, t)
 644                         damon_destroy_region(r, t);
 645         }
 646
 647         while (pos < len) {
 648                 ret = sscanf(&str[pos], "%d %lu %lu%n",
 649                                 &target_idx, &ar.start, &ar.end, &parsed);
 650                 if (ret != 3)
 651                         break;
 652                 err = add_init_region(c, target_idx, &ar);
 653                 if (err)
 654                         goto fail;
 655                 pos += parsed;
 656         }
 657
 658         return 0;
 659
 660 fail:
 661         damon_for_each_target(t, c) {
 662                 damon_for_each_region_safe(r, next, t)
 663                         damon_destroy_region(r, t);
 664         }
 665         return err;
 666 }
 667
 668 static ssize_t dbgfs_init_regions_write(struct file *file,
 669                                           const char __user *buf, size_t count,
 670                                           loff_t *ppos)
 671 {
 672         struct damon_ctx *ctx = file->private_data;
 673         char *kbuf;
 674         ssize_t ret = count;
 675         int err;
 676
 677         kbuf = user_input_str(buf, count, ppos);
 678         if (IS_ERR(kbuf))
 679                 return PTR_ERR(kbuf);
 680
 681         mutex_lock(&ctx->kdamond_lock);
 682         if (ctx->kdamond) {
 683                 ret = -EBUSY;
 684                 goto unlock_out;
 685         }
 686
 687         err = set_init_regions(ctx, kbuf, ret);
 688         if (err)
 689                 ret = err;
 690
 691 unlock_out:
 692         mutex_unlock(&ctx->kdamond_lock);
 693         kfree(kbuf);
 694         return ret;
 695 }
 696
 697 static ssize_t dbgfs_kdamond_pid_read(struct file *file,
 698                 char __user *buf, size_t count, loff_t *ppos)
 699 {
 700         struct damon_ctx *ctx = file->private_data;
 701         char *kbuf;
 702         ssize_t len;
 703
 704         kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
 705         if (!kbuf)
 706                 return -ENOMEM;
 707
 708         mutex_lock(&ctx->kdamond_lock);
 709         if (ctx->kdamond)
 710                 len = scnprintf(kbuf, count, "%d\n", ctx->kdamond->pid);
 711         else
 712                 len = scnprintf(kbuf, count, "none\n");
 713         mutex_unlock(&ctx->kdamond_lock);
 714         if (!len)
 715                 goto out;
 716         len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
 717
 718 out:
 719         kfree(kbuf);
 720         return len;
 721 }
 722
 723 static int damon_dbgfs_open(struct inode *inode, struct file *file)
 724 {
 725         damon_dbgfs_warn_deprecation();
 726
 727         file->private_data = inode->i_private;
 728
 729         return nonseekable_open(inode, file);
 730 }
 731
 732 static const struct file_operations attrs_fops = {
 733         .open = damon_dbgfs_open,
 734         .read = dbgfs_attrs_read,
 735         .write = dbgfs_attrs_write,
 736 };
 737
 738 static const struct file_operations schemes_fops = {
 739         .open = damon_dbgfs_open,
 740         .read = dbgfs_schemes_read,
 741         .write = dbgfs_schemes_write,
 742 };
 743
 744 static const struct file_operations target_ids_fops = {
 745         .open = damon_dbgfs_open,
 746         .read = dbgfs_target_ids_read,
 747         .write = dbgfs_target_ids_write,
 748 };
 749
 750 static const struct file_operations init_regions_fops = {
 751         .open = damon_dbgfs_open,
 752         .read = dbgfs_init_regions_read,
 753         .write = dbgfs_init_regions_write,
 754 };
 755
 756 static const struct file_operations kdamond_pid_fops = {
 757         .open = damon_dbgfs_open,
 758         .read = dbgfs_kdamond_pid_read,
 759 };
 760
 761 static void dbgfs_fill_ctx_dir(struct dentry *dir, struct damon_ctx *ctx)
 762 {
 763         const char * const file_names[] = {"attrs", "schemes", "target_ids",
 764                 "init_regions", "kdamond_pid"};
 765         const struct file_operations *fops[] = {&attrs_fops, &schemes_fops,
 766                 &target_ids_fops, &init_regions_fops, &kdamond_pid_fops};
 767         int i;
 768
 769         for (i = 0; i < ARRAY_SIZE(file_names); i++)
 770                 debugfs_create_file(file_names[i], 0600, dir, ctx, fops[i]);
 771 }
 772
 773 static void dbgfs_before_terminate(struct damon_ctx *ctx)
 774 {
 775         struct damon_target *t, *next;
 776
 777         if (!damon_target_has_pid(ctx))
 778                 return;
 779
 780         mutex_lock(&ctx->kdamond_lock);
 781         damon_for_each_target_safe(t, next, ctx) {
 782                 put_pid(t->pid);
 783                 damon_destroy_target(t);
 784         }
 785         mutex_unlock(&ctx->kdamond_lock);
 786 }
 787
 788 static struct damon_ctx *dbgfs_new_ctx(void)
 789 {
 790         struct damon_ctx *ctx;
 791
 792         ctx = damon_new_ctx();
 793         if (!ctx)
 794                 return NULL;
 795
 796         if (damon_select_ops(ctx, DAMON_OPS_VADDR) &&
 797                         damon_select_ops(ctx, DAMON_OPS_PADDR)) {
 798                 damon_destroy_ctx(ctx);
 799                 return NULL;
 800         }
 801         ctx->callback.before_terminate = dbgfs_before_terminate;
 802         return ctx;
 803 }
 804
 805 static void dbgfs_destroy_ctx(struct damon_ctx *ctx)
 806 {
 807         damon_destroy_ctx(ctx);
 808 }
 809
 810 static ssize_t damon_dbgfs_deprecated_read(struct file *file,
 811                 char __user *buf, size_t count, loff_t *ppos)
 812 {
 813         static const char kbuf[512] = DAMON_DBGFS_DEPRECATION_NOTICE;
 814
 815         return simple_read_from_buffer(buf, count, ppos, kbuf, strlen(kbuf));
 816 }
 817
 818 /*
 819  * Make a context of @name and create a debugfs directory for it.
 820  *
 821  * This function should be called while holding damon_dbgfs_lock.
 822  *
 823  * Returns 0 on success, negative error code otherwise.
 824  */
 825 static int dbgfs_mk_context(char *name)
 826 {
 827         struct dentry *root, **new_dirs, *new_dir;
 828         struct damon_ctx **new_ctxs, *new_ctx;
 829
 830         if (damon_nr_running_ctxs())
 831                 return -EBUSY;
 832
 833         new_ctxs = krealloc(dbgfs_ctxs, sizeof(*dbgfs_ctxs) *
 834                         (dbgfs_nr_ctxs + 1), GFP_KERNEL);
 835         if (!new_ctxs)
 836                 return -ENOMEM;
 837         dbgfs_ctxs = new_ctxs;
 838
 839         new_dirs = krealloc(dbgfs_dirs, sizeof(*dbgfs_dirs) *
 840                         (dbgfs_nr_ctxs + 1), GFP_KERNEL);
 841         if (!new_dirs)
 842                 return -ENOMEM;
 843         dbgfs_dirs = new_dirs;
 844
 845         root = dbgfs_dirs[0];
 846         if (!root)
 847                 return -ENOENT;
 848
 849         new_dir = debugfs_create_dir(name, root);
 850         /* Below check is required for a potential duplicated name case */
 851         if (IS_ERR(new_dir))
 852                 return PTR_ERR(new_dir);
 853         dbgfs_dirs[dbgfs_nr_ctxs] = new_dir;
 854
 855         new_ctx = dbgfs_new_ctx();
 856         if (!new_ctx) {
 857                 debugfs_remove(new_dir);
 858                 dbgfs_dirs[dbgfs_nr_ctxs] = NULL;
 859                 return -ENOMEM;
 860         }
 861
 862         dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx;
 863         dbgfs_fill_ctx_dir(dbgfs_dirs[dbgfs_nr_ctxs],
 864                         dbgfs_ctxs[dbgfs_nr_ctxs]);
 865         dbgfs_nr_ctxs++;
 866
 867         return 0;
 868 }
 869
 870 static ssize_t dbgfs_mk_context_write(struct file *file,
 871                 const char __user *buf, size_t count, loff_t *ppos)
 872 {
 873         char *kbuf;
 874         char *ctx_name;
 875         ssize_t ret;
 876
 877         kbuf = user_input_str(buf, count, ppos);
 878         if (IS_ERR(kbuf))
 879                 return PTR_ERR(kbuf);
 880         ctx_name = kmalloc(count + 1, GFP_KERNEL);
 881         if (!ctx_name) {
 882                 kfree(kbuf);
 883                 return -ENOMEM;
 884         }
 885
 886         /* Trim white space */
 887         if (sscanf(kbuf, "%s", ctx_name) != 1) {
 888                 ret = -EINVAL;
 889                 goto out;
 890         }
 891
 892         mutex_lock(&damon_dbgfs_lock);
 893         ret = dbgfs_mk_context(ctx_name);
 894         if (!ret)
 895                 ret = count;
 896         mutex_unlock(&damon_dbgfs_lock);
 897
 898 out:
 899         kfree(kbuf);
 900         kfree(ctx_name);
 901         return ret;
 902 }
 903
 904 /*
 905  * Remove a context of @name and its debugfs directory.
 906  *
 907  * This function should be called while holding damon_dbgfs_lock.
 908  *
 909  * Return 0 on success, negative error code otherwise.
 910  */
 911 static int dbgfs_rm_context(char *name)
 912 {
 913         struct dentry *root, *dir, **new_dirs;
 914         struct inode *inode;
 915         struct damon_ctx **new_ctxs;
 916         int i, j;
 917         int ret = 0;
 918
 919         if (damon_nr_running_ctxs())
 920                 return -EBUSY;
 921
 922         root = dbgfs_dirs[0];
 923         if (!root)
 924                 return -ENOENT;
 925
 926         dir = debugfs_lookup(name, root);
 927         if (!dir)
 928                 return -ENOENT;
 929
 930         inode = d_inode(dir);
 931         if (!S_ISDIR(inode->i_mode)) {
 932                 ret = -EINVAL;
 933                 goto out_dput;
 934         }
 935
 936         new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs),
 937                         GFP_KERNEL);
 938         if (!new_dirs) {
 939                 ret = -ENOMEM;
 940                 goto out_dput;
 941         }
 942
 943         new_ctxs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_ctxs),
 944                         GFP_KERNEL);
 945         if (!new_ctxs) {
 946                 ret = -ENOMEM;
 947                 goto out_new_dirs;
 948         }
 949
 950         for (i = 0, j = 0; i < dbgfs_nr_ctxs; i++) {
 951                 if (dbgfs_dirs[i] == dir) {
 952                         debugfs_remove(dbgfs_dirs[i]);
 953                         dbgfs_destroy_ctx(dbgfs_ctxs[i]);
 954                         continue;
 955                 }
 956                 new_dirs[j] = dbgfs_dirs[i];
 957                 new_ctxs[j++] = dbgfs_ctxs[i];
 958         }
 959
 960         kfree(dbgfs_dirs);
 961         kfree(dbgfs_ctxs);
 962
 963         dbgfs_dirs = new_dirs;
 964         dbgfs_ctxs = new_ctxs;
 965         dbgfs_nr_ctxs--;
 966
 967         goto out_dput;
 968
 969 out_new_dirs:
 970         kfree(new_dirs);
 971 out_dput:
 972         dput(dir);
 973         return ret;
 974 }
 975
 976 static ssize_t dbgfs_rm_context_write(struct file *file,
 977                 const char __user *buf, size_t count, loff_t *ppos)
 978 {
 979         char *kbuf;
 980         ssize_t ret;
 981         char *ctx_name;
 982
 983         kbuf = user_input_str(buf, count, ppos);
 984         if (IS_ERR(kbuf))
 985                 return PTR_ERR(kbuf);
 986         ctx_name = kmalloc(count + 1, GFP_KERNEL);
 987         if (!ctx_name) {
 988                 kfree(kbuf);
 989                 return -ENOMEM;
 990         }
 991
 992         /* Trim white space */
 993         if (sscanf(kbuf, "%s", ctx_name) != 1) {
 994                 ret = -EINVAL;
 995                 goto out;
 996         }
 997
 998         mutex_lock(&damon_dbgfs_lock);
 999         ret = dbgfs_rm_context(ctx_name);
1000         if (!ret)
1001                 ret = count;
1002         mutex_unlock(&damon_dbgfs_lock);
1003
1004 out:
1005         kfree(kbuf);
1006         kfree(ctx_name);
1007         return ret;
1008 }
1009
1010 static ssize_t dbgfs_monitor_on_read(struct file *file,
1011                 char __user *buf, size_t count, loff_t *ppos)
1012 {
1013         char monitor_on_buf[5];
1014         bool monitor_on = damon_nr_running_ctxs() != 0;
1015         int len;
1016
1017         len = scnprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n");
1018
1019         return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len);
1020 }
1021
1022 static ssize_t dbgfs_monitor_on_write(struct file *file,
1023                 const char __user *buf, size_t count, loff_t *ppos)
1024 {
1025         ssize_t ret;
1026         char *kbuf;
1027
1028         kbuf = user_input_str(buf, count, ppos);
1029         if (IS_ERR(kbuf))
1030                 return PTR_ERR(kbuf);
1031
1032         /* Remove white space */
1033         if (sscanf(kbuf, "%s", kbuf) != 1) {
1034                 kfree(kbuf);
1035                 return -EINVAL;
1036         }
1037
1038         mutex_lock(&damon_dbgfs_lock);
1039         if (!strncmp(kbuf, "on", count)) {
1040                 int i;
1041
1042                 for (i = 0; i < dbgfs_nr_ctxs; i++) {
1043                         if (damon_targets_empty(dbgfs_ctxs[i])) {
1044                                 kfree(kbuf);
1045                                 mutex_unlock(&damon_dbgfs_lock);
1046                                 return -EINVAL;
1047                         }
1048                 }
1049                 ret = damon_start(dbgfs_ctxs, dbgfs_nr_ctxs, true);
1050         } else if (!strncmp(kbuf, "off", count)) {
1051                 ret = damon_stop(dbgfs_ctxs, dbgfs_nr_ctxs);
1052         } else {
1053                 ret = -EINVAL;
1054         }
1055         mutex_unlock(&damon_dbgfs_lock);
1056
1057         if (!ret)
1058                 ret = count;
1059         kfree(kbuf);
1060         return ret;
1061 }
1062
1063 static int damon_dbgfs_static_file_open(struct inode *inode, struct file *file)
1064 {
1065         damon_dbgfs_warn_deprecation();
1066         return nonseekable_open(inode, file);
1067 }
1068
1069 static const struct file_operations deprecated_fops = {
1070         .read = damon_dbgfs_deprecated_read,
1071 };
1072
1073 static const struct file_operations mk_contexts_fops = {
1074         .open = damon_dbgfs_static_file_open,
1075         .write = dbgfs_mk_context_write,
1076 };
1077
1078 static const struct file_operations rm_contexts_fops = {
1079         .open = damon_dbgfs_static_file_open,
1080         .write = dbgfs_rm_context_write,
1081 };
1082
1083 static const struct file_operations monitor_on_fops = {
1084         .open = damon_dbgfs_static_file_open,
1085         .read = dbgfs_monitor_on_read,
1086         .write = dbgfs_monitor_on_write,
1087 };
1088
1089 static int __init __damon_dbgfs_init(void)
1090 {
1091         struct dentry *dbgfs_root;
1092         const char * const file_names[] = {"mk_contexts", "rm_contexts",
1093                 "monitor_on_DEPRECATED", "DEPRECATED"};
1094         const struct file_operations *fops[] = {&mk_contexts_fops,
1095                 &rm_contexts_fops, &monitor_on_fops, &deprecated_fops};
1096         int i;
1097
1098         dbgfs_root = debugfs_create_dir("damon", NULL);
1099
1100         for (i = 0; i < ARRAY_SIZE(file_names); i++)
1101                 debugfs_create_file(file_names[i], 0600, dbgfs_root, NULL,
1102                                 fops[i]);
1103         dbgfs_fill_ctx_dir(dbgfs_root, dbgfs_ctxs[0]);
1104
1105         dbgfs_dirs = kmalloc(sizeof(dbgfs_root), GFP_KERNEL);
1106         if (!dbgfs_dirs) {
1107                 debugfs_remove(dbgfs_root);
1108                 return -ENOMEM;
1109         }
1110         dbgfs_dirs[0] = dbgfs_root;
1111
1112         return 0;
1113 }
1114
1115 /*
1116  * Functions for the initialization
1117  */
1118
1119 static int __init damon_dbgfs_init(void)
1120 {
1121         int rc = -ENOMEM;
1122
1123         mutex_lock(&damon_dbgfs_lock);
1124         dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL);
1125         if (!dbgfs_ctxs)
1126                 goto out;
1127         dbgfs_ctxs[0] = dbgfs_new_ctx();
1128         if (!dbgfs_ctxs[0]) {
1129                 kfree(dbgfs_ctxs);
1130                 goto out;
1131         }
1132         dbgfs_nr_ctxs = 1;
1133
1134         rc = __damon_dbgfs_init();
1135         if (rc) {
1136                 kfree(dbgfs_ctxs[0]);
1137                 kfree(dbgfs_ctxs);
1138                 pr_err("%s: dbgfs init failed\n", __func__);
1139         }
1140
1141 out:
1142         mutex_unlock(&damon_dbgfs_lock);
1143         return rc;
1144 }
1145
1146 module_init(damon_dbgfs_init);
1147
1148 #include "tests/dbgfs-kunit.h"