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); 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 char *kbuf, *nrs; 189 unsigned long *targets; 190 ssize_t nr_targets; 191 ssize_t ret = count; 192 int i; 193 int err; 194 195 kbuf = user_input_str(buf, count, ppos); 196 if (IS_ERR(kbuf)) 197 return PTR_ERR(kbuf); 198 199 nrs = kbuf; 200 201 targets = str_to_target_ids(nrs, ret, &nr_targets); 202 if (!targets) { 203 ret = -ENOMEM; 204 goto out; 205 } 206 207 if (targetid_is_pid(ctx)) { 208 for (i = 0; i < nr_targets; i++) { 209 targets[i] = (unsigned long)find_get_pid( 210 (int)targets[i]); 211 if (!targets[i]) { 212 dbgfs_put_pids(targets, i); 213 ret = -EINVAL; 214 goto free_targets_out; 215 } 216 } 217 } 218 219 mutex_lock(&ctx->kdamond_lock); 220 if (ctx->kdamond) { 221 if (targetid_is_pid(ctx)) 222 dbgfs_put_pids(targets, nr_targets); 223 ret = -EBUSY; 224 goto unlock_out; 225 } 226 227 err = damon_set_targets(ctx, targets, nr_targets); 228 if (err) { 229 if (targetid_is_pid(ctx)) 230 dbgfs_put_pids(targets, nr_targets); 231 ret = err; 232 } 233 234 unlock_out: 235 mutex_unlock(&ctx->kdamond_lock); 236 free_targets_out: 237 kfree(targets); 238 out: 239 kfree(kbuf); 240 return ret; 241 } 242 243 static ssize_t dbgfs_kdamond_pid_read(struct file *file, 244 char __user *buf, size_t count, loff_t *ppos) 245 { 246 struct damon_ctx *ctx = file->private_data; 247 char *kbuf; 248 ssize_t len; 249 250 kbuf = kmalloc(count, GFP_KERNEL); 251 if (!kbuf) 252 return -ENOMEM; 253 254 mutex_lock(&ctx->kdamond_lock); 255 if (ctx->kdamond) 256 len = scnprintf(kbuf, count, "%d\n", ctx->kdamond->pid); 257 else 258 len = scnprintf(kbuf, count, "none\n"); 259 mutex_unlock(&ctx->kdamond_lock); 260 if (!len) 261 goto out; 262 len = simple_read_from_buffer(buf, count, ppos, kbuf, len); 263 264 out: 265 kfree(kbuf); 266 return len; 267 } 268 269 static int damon_dbgfs_open(struct inode *inode, struct file *file) 270 { 271 file->private_data = inode->i_private; 272 273 return nonseekable_open(inode, file); 274 } 275 276 static const struct file_operations attrs_fops = { 277 .open = damon_dbgfs_open, 278 .read = dbgfs_attrs_read, 279 .write = dbgfs_attrs_write, 280 }; 281 282 static const struct file_operations target_ids_fops = { 283 .open = damon_dbgfs_open, 284 .read = dbgfs_target_ids_read, 285 .write = dbgfs_target_ids_write, 286 }; 287 288 static const struct file_operations kdamond_pid_fops = { 289 .open = damon_dbgfs_open, 290 .read = dbgfs_kdamond_pid_read, 291 }; 292 293 static void dbgfs_fill_ctx_dir(struct dentry *dir, struct damon_ctx *ctx) 294 { 295 const char * const file_names[] = {"attrs", "target_ids", 296 "kdamond_pid"}; 297 const struct file_operations *fops[] = {&attrs_fops, &target_ids_fops, 298 &kdamond_pid_fops}; 299 int i; 300 301 for (i = 0; i < ARRAY_SIZE(file_names); i++) 302 debugfs_create_file(file_names[i], 0600, dir, ctx, fops[i]); 303 } 304 305 static int dbgfs_before_terminate(struct damon_ctx *ctx) 306 { 307 struct damon_target *t, *next; 308 309 if (!targetid_is_pid(ctx)) 310 return 0; 311 312 damon_for_each_target_safe(t, next, ctx) { 313 put_pid((struct pid *)t->id); 314 damon_destroy_target(t); 315 } 316 return 0; 317 } 318 319 static struct damon_ctx *dbgfs_new_ctx(void) 320 { 321 struct damon_ctx *ctx; 322 323 ctx = damon_new_ctx(); 324 if (!ctx) 325 return NULL; 326 327 damon_va_set_primitives(ctx); 328 ctx->callback.before_terminate = dbgfs_before_terminate; 329 return ctx; 330 } 331 332 static void dbgfs_destroy_ctx(struct damon_ctx *ctx) 333 { 334 damon_destroy_ctx(ctx); 335 } 336 337 /* 338 * Make a context of @name and create a debugfs directory for it. 339 * 340 * This function should be called while holding damon_dbgfs_lock. 341 * 342 * Returns 0 on success, negative error code otherwise. 343 */ 344 static int dbgfs_mk_context(char *name) 345 { 346 struct dentry *root, **new_dirs, *new_dir; 347 struct damon_ctx **new_ctxs, *new_ctx; 348 349 if (damon_nr_running_ctxs()) 350 return -EBUSY; 351 352 new_ctxs = krealloc(dbgfs_ctxs, sizeof(*dbgfs_ctxs) * 353 (dbgfs_nr_ctxs + 1), GFP_KERNEL); 354 if (!new_ctxs) 355 return -ENOMEM; 356 dbgfs_ctxs = new_ctxs; 357 358 new_dirs = krealloc(dbgfs_dirs, sizeof(*dbgfs_dirs) * 359 (dbgfs_nr_ctxs + 1), GFP_KERNEL); 360 if (!new_dirs) 361 return -ENOMEM; 362 dbgfs_dirs = new_dirs; 363 364 root = dbgfs_dirs[0]; 365 if (!root) 366 return -ENOENT; 367 368 new_dir = debugfs_create_dir(name, root); 369 dbgfs_dirs[dbgfs_nr_ctxs] = new_dir; 370 371 new_ctx = dbgfs_new_ctx(); 372 if (!new_ctx) { 373 debugfs_remove(new_dir); 374 dbgfs_dirs[dbgfs_nr_ctxs] = NULL; 375 return -ENOMEM; 376 } 377 378 dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx; 379 dbgfs_fill_ctx_dir(dbgfs_dirs[dbgfs_nr_ctxs], 380 dbgfs_ctxs[dbgfs_nr_ctxs]); 381 dbgfs_nr_ctxs++; 382 383 return 0; 384 } 385 386 static ssize_t dbgfs_mk_context_write(struct file *file, 387 const char __user *buf, size_t count, loff_t *ppos) 388 { 389 char *kbuf; 390 char *ctx_name; 391 ssize_t ret = count; 392 int err; 393 394 kbuf = user_input_str(buf, count, ppos); 395 if (IS_ERR(kbuf)) 396 return PTR_ERR(kbuf); 397 ctx_name = kmalloc(count + 1, GFP_KERNEL); 398 if (!ctx_name) { 399 kfree(kbuf); 400 return -ENOMEM; 401 } 402 403 /* Trim white space */ 404 if (sscanf(kbuf, "%s", ctx_name) != 1) { 405 ret = -EINVAL; 406 goto out; 407 } 408 409 mutex_lock(&damon_dbgfs_lock); 410 err = dbgfs_mk_context(ctx_name); 411 if (err) 412 ret = err; 413 mutex_unlock(&damon_dbgfs_lock); 414 415 out: 416 kfree(kbuf); 417 kfree(ctx_name); 418 return ret; 419 } 420 421 /* 422 * Remove a context of @name and its debugfs directory. 423 * 424 * This function should be called while holding damon_dbgfs_lock. 425 * 426 * Return 0 on success, negative error code otherwise. 427 */ 428 static int dbgfs_rm_context(char *name) 429 { 430 struct dentry *root, *dir, **new_dirs; 431 struct damon_ctx **new_ctxs; 432 int i, j; 433 434 if (damon_nr_running_ctxs()) 435 return -EBUSY; 436 437 root = dbgfs_dirs[0]; 438 if (!root) 439 return -ENOENT; 440 441 dir = debugfs_lookup(name, root); 442 if (!dir) 443 return -ENOENT; 444 445 new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs), 446 GFP_KERNEL); 447 if (!new_dirs) 448 return -ENOMEM; 449 450 new_ctxs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_ctxs), 451 GFP_KERNEL); 452 if (!new_ctxs) { 453 kfree(new_dirs); 454 return -ENOMEM; 455 } 456 457 for (i = 0, j = 0; i < dbgfs_nr_ctxs; i++) { 458 if (dbgfs_dirs[i] == dir) { 459 debugfs_remove(dbgfs_dirs[i]); 460 dbgfs_destroy_ctx(dbgfs_ctxs[i]); 461 continue; 462 } 463 new_dirs[j] = dbgfs_dirs[i]; 464 new_ctxs[j++] = dbgfs_ctxs[i]; 465 } 466 467 kfree(dbgfs_dirs); 468 kfree(dbgfs_ctxs); 469 470 dbgfs_dirs = new_dirs; 471 dbgfs_ctxs = new_ctxs; 472 dbgfs_nr_ctxs--; 473 474 return 0; 475 } 476 477 static ssize_t dbgfs_rm_context_write(struct file *file, 478 const char __user *buf, size_t count, loff_t *ppos) 479 { 480 char *kbuf; 481 ssize_t ret = count; 482 int err; 483 char *ctx_name; 484 485 kbuf = user_input_str(buf, count, ppos); 486 if (IS_ERR(kbuf)) 487 return PTR_ERR(kbuf); 488 ctx_name = kmalloc(count + 1, GFP_KERNEL); 489 if (!ctx_name) { 490 kfree(kbuf); 491 return -ENOMEM; 492 } 493 494 /* Trim white space */ 495 if (sscanf(kbuf, "%s", ctx_name) != 1) { 496 ret = -EINVAL; 497 goto out; 498 } 499 500 mutex_lock(&damon_dbgfs_lock); 501 err = dbgfs_rm_context(ctx_name); 502 if (err) 503 ret = err; 504 mutex_unlock(&damon_dbgfs_lock); 505 506 out: 507 kfree(kbuf); 508 kfree(ctx_name); 509 return ret; 510 } 511 512 static ssize_t dbgfs_monitor_on_read(struct file *file, 513 char __user *buf, size_t count, loff_t *ppos) 514 { 515 char monitor_on_buf[5]; 516 bool monitor_on = damon_nr_running_ctxs() != 0; 517 int len; 518 519 len = scnprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n"); 520 521 return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len); 522 } 523 524 static ssize_t dbgfs_monitor_on_write(struct file *file, 525 const char __user *buf, size_t count, loff_t *ppos) 526 { 527 ssize_t ret = count; 528 char *kbuf; 529 int err; 530 531 kbuf = user_input_str(buf, count, ppos); 532 if (IS_ERR(kbuf)) 533 return PTR_ERR(kbuf); 534 535 /* Remove white space */ 536 if (sscanf(kbuf, "%s", kbuf) != 1) { 537 kfree(kbuf); 538 return -EINVAL; 539 } 540 541 if (!strncmp(kbuf, "on", count)) 542 err = damon_start(dbgfs_ctxs, dbgfs_nr_ctxs); 543 else if (!strncmp(kbuf, "off", count)) 544 err = damon_stop(dbgfs_ctxs, dbgfs_nr_ctxs); 545 else 546 err = -EINVAL; 547 548 if (err) 549 ret = err; 550 kfree(kbuf); 551 return ret; 552 } 553 554 static const struct file_operations mk_contexts_fops = { 555 .write = dbgfs_mk_context_write, 556 }; 557 558 static const struct file_operations rm_contexts_fops = { 559 .write = dbgfs_rm_context_write, 560 }; 561 562 static const struct file_operations monitor_on_fops = { 563 .read = dbgfs_monitor_on_read, 564 .write = dbgfs_monitor_on_write, 565 }; 566 567 static int __init __damon_dbgfs_init(void) 568 { 569 struct dentry *dbgfs_root; 570 const char * const file_names[] = {"mk_contexts", "rm_contexts", 571 "monitor_on"}; 572 const struct file_operations *fops[] = {&mk_contexts_fops, 573 &rm_contexts_fops, &monitor_on_fops}; 574 int i; 575 576 dbgfs_root = debugfs_create_dir("damon", NULL); 577 578 for (i = 0; i < ARRAY_SIZE(file_names); i++) 579 debugfs_create_file(file_names[i], 0600, dbgfs_root, NULL, 580 fops[i]); 581 dbgfs_fill_ctx_dir(dbgfs_root, dbgfs_ctxs[0]); 582 583 dbgfs_dirs = kmalloc_array(1, sizeof(dbgfs_root), GFP_KERNEL); 584 if (!dbgfs_dirs) { 585 debugfs_remove(dbgfs_root); 586 return -ENOMEM; 587 } 588 dbgfs_dirs[0] = dbgfs_root; 589 590 return 0; 591 } 592 593 /* 594 * Functions for the initialization 595 */ 596 597 static int __init damon_dbgfs_init(void) 598 { 599 int rc; 600 601 dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL); 602 if (!dbgfs_ctxs) 603 return -ENOMEM; 604 dbgfs_ctxs[0] = dbgfs_new_ctx(); 605 if (!dbgfs_ctxs[0]) { 606 kfree(dbgfs_ctxs); 607 return -ENOMEM; 608 } 609 dbgfs_nr_ctxs = 1; 610 611 rc = __damon_dbgfs_init(); 612 if (rc) { 613 kfree(dbgfs_ctxs[0]); 614 kfree(dbgfs_ctxs); 615 pr_err("%s: dbgfs init failed\n", __func__); 616 } 617 618 return rc; 619 } 620 621 module_init(damon_dbgfs_init); 622 623 #include "dbgfs-test.h" 624