mm/damon/dbgfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * DAMON Debugfs Interface
   4  *
   5  * Author: SeongJae Park <sjpark@amazon.de>
   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 static struct damon_ctx **dbgfs_ctxs;
  19 static int dbgfs_nr_ctxs;
  20 static struct dentry **dbgfs_dirs;
  21 static DEFINE_MUTEX(damon_dbgfs_lock);
  22
  23 /*
  24  * Returns non-empty string on success, negative error code otherwise.
  25  */
  26 static char *user_input_str(const char __user *buf, size_t count, loff_t *ppos)
  27 {
  28         char *kbuf;
  29         ssize_t ret;
  30
  31         /* We do not accept continuous write */
  32         if (*ppos)
  33                 return ERR_PTR(-EINVAL);
  34
  35         kbuf = kmalloc(count + 1, GFP_KERNEL | __GFP_NOWARN);
  36         if (!kbuf)
  37                 return ERR_PTR(-ENOMEM);
  38
  39         ret = simple_write_to_buffer(kbuf, count + 1, ppos, buf, count);
  40         if (ret != count) {
  41                 kfree(kbuf);
  42                 return ERR_PTR(-EIO);
  43         }
  44         kbuf[ret] = '\0';
  45
  46         return kbuf;
  47 }
  48
  49 static ssize_t dbgfs_attrs_read(struct file *file,
  50                 char __user *buf, size_t count, loff_t *ppos)
  51 {
  52         struct damon_ctx *ctx = file->private_data;
  53         char kbuf[128];
  54         int ret;
  55
  56         mutex_lock(&ctx->kdamond_lock);
  57         ret = scnprintf(kbuf, ARRAY_SIZE(kbuf), "%lu %lu %lu %lu %lu\n",
  58                         ctx->sample_interval, ctx->aggr_interval,
  59                         ctx->primitive_update_interval, ctx->min_nr_regions,
  60                         ctx->max_nr_regions);
  61         mutex_unlock(&ctx->kdamond_lock);
  62
  63         return simple_read_from_buffer(buf, count, ppos, kbuf, ret);
  64 }
  65
  66 static ssize_t dbgfs_attrs_write(struct file *file,
  67                 const char __user *buf, size_t count, loff_t *ppos)
  68 {
  69         struct damon_ctx *ctx = file->private_data;
  70         unsigned long s, a, r, minr, maxr;
  71         char *kbuf;
  72         ssize_t ret = count;
  73         int err;
  74
  75         kbuf = user_input_str(buf, count, ppos);
  76         if (IS_ERR(kbuf))
  77                 return PTR_ERR(kbuf);
  78
  79         if (sscanf(kbuf, "%lu %lu %lu %lu %lu",
  80                                 &s, &a, &r, &minr, &maxr) != 5) {
  81                 ret = -EINVAL;
  82                 goto out;
  83         }
  84
  85         mutex_lock(&ctx->kdamond_lock);
  86         if (ctx->kdamond) {
  87                 ret = -EBUSY;
  88                 goto unlock_out;
  89         }
  90
  91         err = damon_set_attrs(ctx, s, a, r, minr, maxr);
  92         if (err)
  93                 ret = err;
  94 unlock_out:
  95         mutex_unlock(&ctx->kdamond_lock);
  96 out:
  97         kfree(kbuf);
  98         return ret;
  99 }
 100
 101 static inline bool targetid_is_pid(const struct damon_ctx *ctx)
 102 {
 103         return ctx->primitive.target_valid == damon_va_target_valid;
 104 }
 105
 106 static ssize_t sprint_target_ids(struct damon_ctx *ctx, char *buf, ssize_t len)
 107 {
 108         struct damon_target *t;
 109         unsigned long id;
 110         int written = 0;
 111         int rc;
 112
 113         damon_for_each_target(t, ctx) {
 114                 id = t->id;
 115                 if (targetid_is_pid(ctx))
 116                         /* Show pid numbers to debugfs users */
 117                         id = (unsigned long)pid_vnr((struct pid *)id);
 118
 119                 rc = scnprintf(&buf[written], len - written, "%lu ", id);
 120                 if (!rc)
 121                         return -ENOMEM;
 122                 written += rc;
 123         }
 124         if (written)
 125                 written -= 1;
 126         written += scnprintf(&buf[written], len - written, "\n");
 127         return written;
 128 }
 129
 130 static ssize_t dbgfs_target_ids_read(struct file *file,
 131                 char __user *buf, size_t count, loff_t *ppos)
 132 {
 133         struct damon_ctx *ctx = file->private_data;
 134         ssize_t len;
 135         char ids_buf[320];
 136
 137         mutex_lock(&ctx->kdamond_lock);
 138         len = sprint_target_ids(ctx, ids_buf, 320);
 139         mutex_unlock(&ctx->kdamond_lock);
 140         if (len < 0)
 141                 return len;
 142
 143         return simple_read_from_buffer(buf, count, ppos, ids_buf, len);
 144 }
 145
 146 /*
 147  * Converts a string into an array of unsigned long integers
 148  *
 149  * Returns an array of unsigned long integers if the conversion success, or
 150  * NULL otherwise.
 151  */
 152 static unsigned long *str_to_target_ids(const char *str, ssize_t len,
 153                                         ssize_t *nr_ids)
 154 {
 155         unsigned long *ids;
 156         const int max_nr_ids = 32;
 157         unsigned long id;
 158         int pos = 0, parsed, ret;
 159
 160         *nr_ids = 0;
 161         ids = kmalloc_array(max_nr_ids, sizeof(id), GFP_KERNEL);
 162         if (!ids)
 163                 return NULL;
 164         while (*nr_ids < max_nr_ids && pos < len) {
 165                 ret = sscanf(&str[pos], "%lu%n", &id, &parsed);
 166                 pos += parsed;
 167                 if (ret != 1)
 168                         break;
 169                 ids[*nr_ids] = id;
 170                 *nr_ids += 1;
 171         }
 172
 173         return ids;
 174 }
 175
 176 static void dbgfs_put_pids(unsigned long *ids, int nr_ids)
 177 {
 178         int i;
 179
 180         for (i = 0; i < nr_ids; i++)
 181                 put_pid((struct pid *)ids[i]);
 182 }
 183
 184 static ssize_t dbgfs_target_ids_write(struct file *file,
 185                 const char __user *buf, size_t count, loff_t *ppos)
 186 {
 187         struct damon_ctx *ctx = file->private_data;
 188         struct damon_target *t, *next_t;
 189         char *kbuf, *nrs;
 190         unsigned long *targets;
 191         ssize_t nr_targets;
 192         ssize_t ret = count;
 193         int i;
 194         int err;
 195
 196         kbuf = user_input_str(buf, count, ppos);
 197         if (IS_ERR(kbuf))
 198                 return PTR_ERR(kbuf);
 199
 200         nrs = kbuf;
 201
 202         targets = str_to_target_ids(nrs, ret, &nr_targets);
 203         if (!targets) {
 204                 ret = -ENOMEM;
 205                 goto out;
 206         }
 207
 208         if (targetid_is_pid(ctx)) {
 209                 for (i = 0; i < nr_targets; i++) {
 210                         targets[i] = (unsigned long)find_get_pid(
 211                                         (int)targets[i]);
 212                         if (!targets[i]) {
 213                                 dbgfs_put_pids(targets, i);
 214                                 ret = -EINVAL;
 215                                 goto free_targets_out;
 216                         }
 217                 }
 218         }
 219
 220         mutex_lock(&ctx->kdamond_lock);
 221         if (ctx->kdamond) {
 222                 if (targetid_is_pid(ctx))
 223                         dbgfs_put_pids(targets, nr_targets);
 224                 ret = -EBUSY;
 225                 goto unlock_out;
 226         }
 227
 228         /* remove previously set targets */
 229         damon_for_each_target_safe(t, next_t, ctx) {
 230                 if (targetid_is_pid(ctx))
 231                         put_pid((struct pid *)t->id);
 232                 damon_destroy_target(t);
 233         }
 234
 235         err = damon_set_targets(ctx, targets, nr_targets);
 236         if (err) {
 237                 if (targetid_is_pid(ctx))
 238                         dbgfs_put_pids(targets, nr_targets);
 239                 ret = err;
 240         }
 241
 242 unlock_out:
 243         mutex_unlock(&ctx->kdamond_lock);
 244 free_targets_out:
 245         kfree(targets);
 246 out:
 247         kfree(kbuf);
 248         return ret;
 249 }
 250
 251 static ssize_t dbgfs_kdamond_pid_read(struct file *file,
 252                 char __user *buf, size_t count, loff_t *ppos)
 253 {
 254         struct damon_ctx *ctx = file->private_data;
 255         char *kbuf;
 256         ssize_t len;
 257
 258         kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
 259         if (!kbuf)
 260                 return -ENOMEM;
 261
 262         mutex_lock(&ctx->kdamond_lock);
 263         if (ctx->kdamond)
 264                 len = scnprintf(kbuf, count, "%d\n", ctx->kdamond->pid);
 265         else
 266                 len = scnprintf(kbuf, count, "none\n");
 267         mutex_unlock(&ctx->kdamond_lock);
 268         if (!len)
 269                 goto out;
 270         len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
 271
 272 out:
 273         kfree(kbuf);
 274         return len;
 275 }
 276
 277 static int damon_dbgfs_open(struct inode *inode, struct file *file)
 278 {
 279         file->private_data = inode->i_private;
 280
 281         return nonseekable_open(inode, file);
 282 }
 283
 284 static const struct file_operations attrs_fops = {
 285         .open = damon_dbgfs_open,
 286         .read = dbgfs_attrs_read,
 287         .write = dbgfs_attrs_write,
 288 };
 289
 290 static const struct file_operations target_ids_fops = {
 291         .open = damon_dbgfs_open,
 292         .read = dbgfs_target_ids_read,
 293         .write = dbgfs_target_ids_write,
 294 };
 295
 296 static const struct file_operations kdamond_pid_fops = {
 297         .open = damon_dbgfs_open,
 298         .read = dbgfs_kdamond_pid_read,
 299 };
 300
 301 static void dbgfs_fill_ctx_dir(struct dentry *dir, struct damon_ctx *ctx)
 302 {
 303         const char * const file_names[] = {"attrs", "target_ids",
 304                 "kdamond_pid"};
 305         const struct file_operations *fops[] = {&attrs_fops, &target_ids_fops,
 306                 &kdamond_pid_fops};
 307         int i;
 308
 309         for (i = 0; i < ARRAY_SIZE(file_names); i++)
 310                 debugfs_create_file(file_names[i], 0600, dir, ctx, fops[i]);
 311 }
 312
 313 static int dbgfs_before_terminate(struct damon_ctx *ctx)
 314 {
 315         struct damon_target *t, *next;
 316
 317         if (!targetid_is_pid(ctx))
 318                 return 0;
 319
 320         mutex_lock(&ctx->kdamond_lock);
 321         damon_for_each_target_safe(t, next, ctx) {
 322                 put_pid((struct pid *)t->id);
 323                 damon_destroy_target(t);
 324         }
 325         mutex_unlock(&ctx->kdamond_lock);
 326         return 0;
 327 }
 328
 329 static struct damon_ctx *dbgfs_new_ctx(void)
 330 {
 331         struct damon_ctx *ctx;
 332
 333         ctx = damon_new_ctx();
 334         if (!ctx)
 335                 return NULL;
 336
 337         damon_va_set_primitives(ctx);
 338         ctx->callback.before_terminate = dbgfs_before_terminate;
 339         return ctx;
 340 }
 341
 342 static void dbgfs_destroy_ctx(struct damon_ctx *ctx)
 343 {
 344         damon_destroy_ctx(ctx);
 345 }
 346
 347 /*
 348  * Make a context of @name and create a debugfs directory for it.
 349  *
 350  * This function should be called while holding damon_dbgfs_lock.
 351  *
 352  * Returns 0 on success, negative error code otherwise.
 353  */
 354 static int dbgfs_mk_context(char *name)
 355 {
 356         struct dentry *root, **new_dirs, *new_dir;
 357         struct damon_ctx **new_ctxs, *new_ctx;
 358
 359         if (damon_nr_running_ctxs())
 360                 return -EBUSY;
 361
 362         new_ctxs = krealloc(dbgfs_ctxs, sizeof(*dbgfs_ctxs) *
 363                         (dbgfs_nr_ctxs + 1), GFP_KERNEL);
 364         if (!new_ctxs)
 365                 return -ENOMEM;
 366         dbgfs_ctxs = new_ctxs;
 367
 368         new_dirs = krealloc(dbgfs_dirs, sizeof(*dbgfs_dirs) *
 369                         (dbgfs_nr_ctxs + 1), GFP_KERNEL);
 370         if (!new_dirs)
 371                 return -ENOMEM;
 372         dbgfs_dirs = new_dirs;
 373
 374         root = dbgfs_dirs[0];
 375         if (!root)
 376                 return -ENOENT;
 377
 378         new_dir = debugfs_create_dir(name, root);
 379         /* Below check is required for a potential duplicated name case */
 380         if (IS_ERR(new_dir))
 381                 return PTR_ERR(new_dir);
 382         dbgfs_dirs[dbgfs_nr_ctxs] = new_dir;
 383
 384         new_ctx = dbgfs_new_ctx();
 385         if (!new_ctx) {
 386                 debugfs_remove(new_dir);
 387                 dbgfs_dirs[dbgfs_nr_ctxs] = NULL;
 388                 return -ENOMEM;
 389         }
 390
 391         dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx;
 392         dbgfs_fill_ctx_dir(dbgfs_dirs[dbgfs_nr_ctxs],
 393                         dbgfs_ctxs[dbgfs_nr_ctxs]);
 394         dbgfs_nr_ctxs++;
 395
 396         return 0;
 397 }
 398
 399 static ssize_t dbgfs_mk_context_write(struct file *file,
 400                 const char __user *buf, size_t count, loff_t *ppos)
 401 {
 402         char *kbuf;
 403         char *ctx_name;
 404         ssize_t ret = count;
 405         int err;
 406
 407         kbuf = user_input_str(buf, count, ppos);
 408         if (IS_ERR(kbuf))
 409                 return PTR_ERR(kbuf);
 410         ctx_name = kmalloc(count + 1, GFP_KERNEL);
 411         if (!ctx_name) {
 412                 kfree(kbuf);
 413                 return -ENOMEM;
 414         }
 415
 416         /* Trim white space */
 417         if (sscanf(kbuf, "%s", ctx_name) != 1) {
 418                 ret = -EINVAL;
 419                 goto out;
 420         }
 421
 422         mutex_lock(&damon_dbgfs_lock);
 423         err = dbgfs_mk_context(ctx_name);
 424         if (err)
 425                 ret = err;
 426         mutex_unlock(&damon_dbgfs_lock);
 427
 428 out:
 429         kfree(kbuf);
 430         kfree(ctx_name);
 431         return ret;
 432 }
 433
 434 /*
 435  * Remove a context of @name and its debugfs directory.
 436  *
 437  * This function should be called while holding damon_dbgfs_lock.
 438  *
 439  * Return 0 on success, negative error code otherwise.
 440  */
 441 static int dbgfs_rm_context(char *name)
 442 {
 443         struct dentry *root, *dir, **new_dirs;
 444         struct inode *inode;
 445         struct damon_ctx **new_ctxs;
 446         int i, j;
 447         int ret = 0;
 448
 449         if (damon_nr_running_ctxs())
 450                 return -EBUSY;
 451
 452         root = dbgfs_dirs[0];
 453         if (!root)
 454                 return -ENOENT;
 455
 456         dir = debugfs_lookup(name, root);
 457         if (!dir)
 458                 return -ENOENT;
 459
 460         inode = d_inode(dir);
 461         if (!S_ISDIR(inode->i_mode)) {
 462                 ret = -EINVAL;
 463                 goto out_dput;
 464         }
 465
 466         new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs),
 467                         GFP_KERNEL);
 468         if (!new_dirs) {
 469                 ret = -ENOMEM;
 470                 goto out_dput;
 471         }
 472
 473         new_ctxs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_ctxs),
 474                         GFP_KERNEL);
 475         if (!new_ctxs) {
 476                 ret = -ENOMEM;
 477                 goto out_new_dirs;
 478         }
 479
 480         for (i = 0, j = 0; i < dbgfs_nr_ctxs; i++) {
 481                 if (dbgfs_dirs[i] == dir) {
 482                         debugfs_remove(dbgfs_dirs[i]);
 483                         dbgfs_destroy_ctx(dbgfs_ctxs[i]);
 484                         continue;
 485                 }
 486                 new_dirs[j] = dbgfs_dirs[i];
 487                 new_ctxs[j++] = dbgfs_ctxs[i];
 488         }
 489
 490         kfree(dbgfs_dirs);
 491         kfree(dbgfs_ctxs);
 492
 493         dbgfs_dirs = new_dirs;
 494         dbgfs_ctxs = new_ctxs;
 495         dbgfs_nr_ctxs--;
 496
 497         goto out_dput;
 498
 499 out_new_dirs:
 500         kfree(new_dirs);
 501 out_dput:
 502         dput(dir);
 503         return ret;
 504 }
 505
 506 static ssize_t dbgfs_rm_context_write(struct file *file,
 507                 const char __user *buf, size_t count, loff_t *ppos)
 508 {
 509         char *kbuf;
 510         ssize_t ret = count;
 511         int err;
 512         char *ctx_name;
 513
 514         kbuf = user_input_str(buf, count, ppos);
 515         if (IS_ERR(kbuf))
 516                 return PTR_ERR(kbuf);
 517         ctx_name = kmalloc(count + 1, GFP_KERNEL);
 518         if (!ctx_name) {
 519                 kfree(kbuf);
 520                 return -ENOMEM;
 521         }
 522
 523         /* Trim white space */
 524         if (sscanf(kbuf, "%s", ctx_name) != 1) {
 525                 ret = -EINVAL;
 526                 goto out;
 527         }
 528
 529         mutex_lock(&damon_dbgfs_lock);
 530         err = dbgfs_rm_context(ctx_name);
 531         if (err)
 532                 ret = err;
 533         mutex_unlock(&damon_dbgfs_lock);
 534
 535 out:
 536         kfree(kbuf);
 537         kfree(ctx_name);
 538         return ret;
 539 }
 540
 541 static ssize_t dbgfs_monitor_on_read(struct file *file,
 542                 char __user *buf, size_t count, loff_t *ppos)
 543 {
 544         char monitor_on_buf[5];
 545         bool monitor_on = damon_nr_running_ctxs() != 0;
 546         int len;
 547
 548         len = scnprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n");
 549
 550         return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len);
 551 }
 552
 553 static ssize_t dbgfs_monitor_on_write(struct file *file,
 554                 const char __user *buf, size_t count, loff_t *ppos)
 555 {
 556         ssize_t ret = count;
 557         char *kbuf;
 558         int err;
 559
 560         kbuf = user_input_str(buf, count, ppos);
 561         if (IS_ERR(kbuf))
 562                 return PTR_ERR(kbuf);
 563
 564         /* Remove white space */
 565         if (sscanf(kbuf, "%s", kbuf) != 1) {
 566                 kfree(kbuf);
 567                 return -EINVAL;
 568         }
 569
 570         mutex_lock(&damon_dbgfs_lock);
 571         if (!strncmp(kbuf, "on", count))
 572                 err = damon_start(dbgfs_ctxs, dbgfs_nr_ctxs);
 573         else if (!strncmp(kbuf, "off", count))
 574                 err = damon_stop(dbgfs_ctxs, dbgfs_nr_ctxs);
 575         else
 576                 err = -EINVAL;
 577         mutex_unlock(&damon_dbgfs_lock);
 578
 579         if (err)
 580                 ret = err;
 581         kfree(kbuf);
 582         return ret;
 583 }
 584
 585 static const struct file_operations mk_contexts_fops = {
 586         .write = dbgfs_mk_context_write,
 587 };
 588
 589 static const struct file_operations rm_contexts_fops = {
 590         .write = dbgfs_rm_context_write,
 591 };
 592
 593 static const struct file_operations monitor_on_fops = {
 594         .read = dbgfs_monitor_on_read,
 595         .write = dbgfs_monitor_on_write,
 596 };
 597
 598 static int __init __damon_dbgfs_init(void)
 599 {
 600         struct dentry *dbgfs_root;
 601         const char * const file_names[] = {"mk_contexts", "rm_contexts",
 602                 "monitor_on"};
 603         const struct file_operations *fops[] = {&mk_contexts_fops,
 604                 &rm_contexts_fops, &monitor_on_fops};
 605         int i;
 606
 607         dbgfs_root = debugfs_create_dir("damon", NULL);
 608
 609         for (i = 0; i < ARRAY_SIZE(file_names); i++)
 610                 debugfs_create_file(file_names[i], 0600, dbgfs_root, NULL,
 611                                 fops[i]);
 612         dbgfs_fill_ctx_dir(dbgfs_root, dbgfs_ctxs[0]);
 613
 614         dbgfs_dirs = kmalloc_array(1, sizeof(dbgfs_root), GFP_KERNEL);
 615         if (!dbgfs_dirs) {
 616                 debugfs_remove(dbgfs_root);
 617                 return -ENOMEM;
 618         }
 619         dbgfs_dirs[0] = dbgfs_root;
 620
 621         return 0;
 622 }
 623
 624 /*
 625  * Functions for the initialization
 626  */
 627
 628 static int __init damon_dbgfs_init(void)
 629 {
 630         int rc = -ENOMEM;
 631
 632         mutex_lock(&damon_dbgfs_lock);
 633         dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL);
 634         if (!dbgfs_ctxs)
 635                 goto out;
 636         dbgfs_ctxs[0] = dbgfs_new_ctx();
 637         if (!dbgfs_ctxs[0]) {
 638                 kfree(dbgfs_ctxs);
 639                 goto out;
 640         }
 641         dbgfs_nr_ctxs = 1;
 642
 643         rc = __damon_dbgfs_init();
 644         if (rc) {
 645                 kfree(dbgfs_ctxs[0]);
 646                 kfree(dbgfs_ctxs);
 647                 pr_err("%s: dbgfs init failed\n", __func__);
 648         }
 649
 650 out:
 651         mutex_unlock(&damon_dbgfs_lock);
 652         return rc;
 653 }
 654
 655 module_init(damon_dbgfs_init);
 656
 657 #include "dbgfs-test.h"