1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 /* 2 /*
3 * DAMON sysfs Interface 3 * DAMON sysfs Interface
4 * 4 *
5 * Copyright (c) 2022 SeongJae Park <sj@kernel 5 * Copyright (c) 2022 SeongJae Park <sj@kernel.org>
6 */ 6 */
7 7
8 #include <linux/pid.h> 8 #include <linux/pid.h>
9 #include <linux/sched.h> 9 #include <linux/sched.h>
10 #include <linux/slab.h> 10 #include <linux/slab.h>
11 11
12 #include "sysfs-common.h" 12 #include "sysfs-common.h"
13 13
14 /* 14 /*
15 * init region directory 15 * init region directory
16 */ 16 */
17 17
18 struct damon_sysfs_region { 18 struct damon_sysfs_region {
19 struct kobject kobj; 19 struct kobject kobj;
20 struct damon_addr_range ar; 20 struct damon_addr_range ar;
21 }; 21 };
22 22
23 static struct damon_sysfs_region *damon_sysfs_ 23 static struct damon_sysfs_region *damon_sysfs_region_alloc(void)
24 { 24 {
25 return kzalloc(sizeof(struct damon_sys 25 return kzalloc(sizeof(struct damon_sysfs_region), GFP_KERNEL);
26 } 26 }
27 27
28 static ssize_t start_show(struct kobject *kobj 28 static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,
29 char *buf) 29 char *buf)
30 { 30 {
31 struct damon_sysfs_region *region = co 31 struct damon_sysfs_region *region = container_of(kobj,
32 struct damon_sysfs_reg 32 struct damon_sysfs_region, kobj);
33 33
34 return sysfs_emit(buf, "%lu\n", region 34 return sysfs_emit(buf, "%lu\n", region->ar.start);
35 } 35 }
36 36
37 static ssize_t start_store(struct kobject *kob 37 static ssize_t start_store(struct kobject *kobj, struct kobj_attribute *attr,
38 const char *buf, size_t count) 38 const char *buf, size_t count)
39 { 39 {
40 struct damon_sysfs_region *region = co 40 struct damon_sysfs_region *region = container_of(kobj,
41 struct damon_sysfs_reg 41 struct damon_sysfs_region, kobj);
42 int err = kstrtoul(buf, 0, ®ion->ar 42 int err = kstrtoul(buf, 0, ®ion->ar.start);
43 43
44 return err ? err : count; 44 return err ? err : count;
45 } 45 }
46 46
47 static ssize_t end_show(struct kobject *kobj, 47 static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr,
48 char *buf) 48 char *buf)
49 { 49 {
50 struct damon_sysfs_region *region = co 50 struct damon_sysfs_region *region = container_of(kobj,
51 struct damon_sysfs_reg 51 struct damon_sysfs_region, kobj);
52 52
53 return sysfs_emit(buf, "%lu\n", region 53 return sysfs_emit(buf, "%lu\n", region->ar.end);
54 } 54 }
55 55
56 static ssize_t end_store(struct kobject *kobj, 56 static ssize_t end_store(struct kobject *kobj, struct kobj_attribute *attr,
57 const char *buf, size_t count) 57 const char *buf, size_t count)
58 { 58 {
59 struct damon_sysfs_region *region = co 59 struct damon_sysfs_region *region = container_of(kobj,
60 struct damon_sysfs_reg 60 struct damon_sysfs_region, kobj);
61 int err = kstrtoul(buf, 0, ®ion->ar 61 int err = kstrtoul(buf, 0, ®ion->ar.end);
62 62
63 return err ? err : count; 63 return err ? err : count;
64 } 64 }
65 65
66 static void damon_sysfs_region_release(struct 66 static void damon_sysfs_region_release(struct kobject *kobj)
67 { 67 {
68 kfree(container_of(kobj, struct damon_ 68 kfree(container_of(kobj, struct damon_sysfs_region, kobj));
69 } 69 }
70 70
71 static struct kobj_attribute damon_sysfs_regio 71 static struct kobj_attribute damon_sysfs_region_start_attr =
72 __ATTR_RW_MODE(start, 0600); 72 __ATTR_RW_MODE(start, 0600);
73 73
74 static struct kobj_attribute damon_sysfs_regio 74 static struct kobj_attribute damon_sysfs_region_end_attr =
75 __ATTR_RW_MODE(end, 0600); 75 __ATTR_RW_MODE(end, 0600);
76 76
77 static struct attribute *damon_sysfs_region_at 77 static struct attribute *damon_sysfs_region_attrs[] = {
78 &damon_sysfs_region_start_attr.attr, 78 &damon_sysfs_region_start_attr.attr,
79 &damon_sysfs_region_end_attr.attr, 79 &damon_sysfs_region_end_attr.attr,
80 NULL, 80 NULL,
81 }; 81 };
82 ATTRIBUTE_GROUPS(damon_sysfs_region); 82 ATTRIBUTE_GROUPS(damon_sysfs_region);
83 83
84 static const struct kobj_type damon_sysfs_regi 84 static const struct kobj_type damon_sysfs_region_ktype = {
85 .release = damon_sysfs_region_release, 85 .release = damon_sysfs_region_release,
86 .sysfs_ops = &kobj_sysfs_ops, 86 .sysfs_ops = &kobj_sysfs_ops,
87 .default_groups = damon_sysfs_region_g 87 .default_groups = damon_sysfs_region_groups,
88 }; 88 };
89 89
90 /* 90 /*
91 * init_regions directory 91 * init_regions directory
92 */ 92 */
93 93
94 struct damon_sysfs_regions { 94 struct damon_sysfs_regions {
95 struct kobject kobj; 95 struct kobject kobj;
96 struct damon_sysfs_region **regions_ar 96 struct damon_sysfs_region **regions_arr;
97 int nr; 97 int nr;
98 }; 98 };
99 99
100 static struct damon_sysfs_regions *damon_sysfs 100 static struct damon_sysfs_regions *damon_sysfs_regions_alloc(void)
101 { 101 {
102 return kzalloc(sizeof(struct damon_sys 102 return kzalloc(sizeof(struct damon_sysfs_regions), GFP_KERNEL);
103 } 103 }
104 104
105 static void damon_sysfs_regions_rm_dirs(struct 105 static void damon_sysfs_regions_rm_dirs(struct damon_sysfs_regions *regions)
106 { 106 {
107 struct damon_sysfs_region **regions_ar 107 struct damon_sysfs_region **regions_arr = regions->regions_arr;
108 int i; 108 int i;
109 109
110 for (i = 0; i < regions->nr; i++) 110 for (i = 0; i < regions->nr; i++)
111 kobject_put(®ions_arr[i]->k 111 kobject_put(®ions_arr[i]->kobj);
112 regions->nr = 0; 112 regions->nr = 0;
113 kfree(regions_arr); 113 kfree(regions_arr);
114 regions->regions_arr = NULL; 114 regions->regions_arr = NULL;
115 } 115 }
116 116
117 static int damon_sysfs_regions_add_dirs(struct 117 static int damon_sysfs_regions_add_dirs(struct damon_sysfs_regions *regions,
118 int nr_regions) 118 int nr_regions)
119 { 119 {
120 struct damon_sysfs_region **regions_ar 120 struct damon_sysfs_region **regions_arr, *region;
121 int err, i; 121 int err, i;
122 122
123 damon_sysfs_regions_rm_dirs(regions); 123 damon_sysfs_regions_rm_dirs(regions);
124 if (!nr_regions) 124 if (!nr_regions)
125 return 0; 125 return 0;
126 126
127 regions_arr = kmalloc_array(nr_regions 127 regions_arr = kmalloc_array(nr_regions, sizeof(*regions_arr),
128 GFP_KERNEL | __GFP_NOW 128 GFP_KERNEL | __GFP_NOWARN);
129 if (!regions_arr) 129 if (!regions_arr)
130 return -ENOMEM; 130 return -ENOMEM;
131 regions->regions_arr = regions_arr; 131 regions->regions_arr = regions_arr;
132 132
133 for (i = 0; i < nr_regions; i++) { 133 for (i = 0; i < nr_regions; i++) {
134 region = damon_sysfs_region_al 134 region = damon_sysfs_region_alloc();
135 if (!region) { 135 if (!region) {
136 damon_sysfs_regions_rm 136 damon_sysfs_regions_rm_dirs(regions);
137 return -ENOMEM; 137 return -ENOMEM;
138 } 138 }
139 139
140 err = kobject_init_and_add(&re 140 err = kobject_init_and_add(®ion->kobj,
141 &damon_sysfs_r 141 &damon_sysfs_region_ktype, ®ions->kobj,
142 "%d", i); 142 "%d", i);
143 if (err) { 143 if (err) {
144 kobject_put(®ion->k 144 kobject_put(®ion->kobj);
145 damon_sysfs_regions_rm 145 damon_sysfs_regions_rm_dirs(regions);
146 return err; 146 return err;
147 } 147 }
148 148
149 regions_arr[i] = region; 149 regions_arr[i] = region;
150 regions->nr++; 150 regions->nr++;
151 } 151 }
152 return 0; 152 return 0;
153 } 153 }
154 154
155 static ssize_t nr_regions_show(struct kobject 155 static ssize_t nr_regions_show(struct kobject *kobj,
156 struct kobj_attribute *attr, c 156 struct kobj_attribute *attr, char *buf)
157 { 157 {
158 struct damon_sysfs_regions *regions = 158 struct damon_sysfs_regions *regions = container_of(kobj,
159 struct damon_sysfs_reg 159 struct damon_sysfs_regions, kobj);
160 160
161 return sysfs_emit(buf, "%d\n", regions 161 return sysfs_emit(buf, "%d\n", regions->nr);
162 } 162 }
163 163
164 static ssize_t nr_regions_store(struct kobject 164 static ssize_t nr_regions_store(struct kobject *kobj,
165 struct kobj_attribute *attr, c 165 struct kobj_attribute *attr, const char *buf, size_t count)
166 { 166 {
167 struct damon_sysfs_regions *regions; 167 struct damon_sysfs_regions *regions;
168 int nr, err = kstrtoint(buf, 0, &nr); 168 int nr, err = kstrtoint(buf, 0, &nr);
169 169
170 if (err) 170 if (err)
171 return err; 171 return err;
172 if (nr < 0) 172 if (nr < 0)
173 return -EINVAL; 173 return -EINVAL;
174 174
175 regions = container_of(kobj, struct da 175 regions = container_of(kobj, struct damon_sysfs_regions, kobj);
176 176
177 if (!mutex_trylock(&damon_sysfs_lock)) 177 if (!mutex_trylock(&damon_sysfs_lock))
178 return -EBUSY; 178 return -EBUSY;
179 err = damon_sysfs_regions_add_dirs(reg 179 err = damon_sysfs_regions_add_dirs(regions, nr);
180 mutex_unlock(&damon_sysfs_lock); 180 mutex_unlock(&damon_sysfs_lock);
181 if (err) 181 if (err)
182 return err; 182 return err;
183 183
184 return count; 184 return count;
185 } 185 }
186 186
187 static void damon_sysfs_regions_release(struct 187 static void damon_sysfs_regions_release(struct kobject *kobj)
188 { 188 {
189 kfree(container_of(kobj, struct damon_ 189 kfree(container_of(kobj, struct damon_sysfs_regions, kobj));
190 } 190 }
191 191
192 static struct kobj_attribute damon_sysfs_regio 192 static struct kobj_attribute damon_sysfs_regions_nr_attr =
193 __ATTR_RW_MODE(nr_regions, 060 193 __ATTR_RW_MODE(nr_regions, 0600);
194 194
195 static struct attribute *damon_sysfs_regions_a 195 static struct attribute *damon_sysfs_regions_attrs[] = {
196 &damon_sysfs_regions_nr_attr.attr, 196 &damon_sysfs_regions_nr_attr.attr,
197 NULL, 197 NULL,
198 }; 198 };
199 ATTRIBUTE_GROUPS(damon_sysfs_regions); 199 ATTRIBUTE_GROUPS(damon_sysfs_regions);
200 200
201 static const struct kobj_type damon_sysfs_regi 201 static const struct kobj_type damon_sysfs_regions_ktype = {
202 .release = damon_sysfs_regions_release 202 .release = damon_sysfs_regions_release,
203 .sysfs_ops = &kobj_sysfs_ops, 203 .sysfs_ops = &kobj_sysfs_ops,
204 .default_groups = damon_sysfs_regions_ 204 .default_groups = damon_sysfs_regions_groups,
205 }; 205 };
206 206
207 /* 207 /*
208 * target directory 208 * target directory
209 */ 209 */
210 210
211 struct damon_sysfs_target { 211 struct damon_sysfs_target {
212 struct kobject kobj; 212 struct kobject kobj;
213 struct damon_sysfs_regions *regions; 213 struct damon_sysfs_regions *regions;
214 int pid; 214 int pid;
215 }; 215 };
216 216
217 static struct damon_sysfs_target *damon_sysfs_ 217 static struct damon_sysfs_target *damon_sysfs_target_alloc(void)
218 { 218 {
219 return kzalloc(sizeof(struct damon_sys 219 return kzalloc(sizeof(struct damon_sysfs_target), GFP_KERNEL);
220 } 220 }
221 221
222 static int damon_sysfs_target_add_dirs(struct 222 static int damon_sysfs_target_add_dirs(struct damon_sysfs_target *target)
223 { 223 {
224 struct damon_sysfs_regions *regions = 224 struct damon_sysfs_regions *regions = damon_sysfs_regions_alloc();
225 int err; 225 int err;
226 226
227 if (!regions) 227 if (!regions)
228 return -ENOMEM; 228 return -ENOMEM;
229 229
230 err = kobject_init_and_add(®ions->k 230 err = kobject_init_and_add(®ions->kobj, &damon_sysfs_regions_ktype,
231 &target->kobj, "region 231 &target->kobj, "regions");
232 if (err) 232 if (err)
233 kobject_put(®ions->kobj); 233 kobject_put(®ions->kobj);
234 else 234 else
235 target->regions = regions; 235 target->regions = regions;
236 return err; 236 return err;
237 } 237 }
238 238
239 static void damon_sysfs_target_rm_dirs(struct 239 static void damon_sysfs_target_rm_dirs(struct damon_sysfs_target *target)
240 { 240 {
241 damon_sysfs_regions_rm_dirs(target->re 241 damon_sysfs_regions_rm_dirs(target->regions);
242 kobject_put(&target->regions->kobj); 242 kobject_put(&target->regions->kobj);
243 } 243 }
244 244
245 static ssize_t pid_target_show(struct kobject 245 static ssize_t pid_target_show(struct kobject *kobj,
246 struct kobj_attribute *attr, c 246 struct kobj_attribute *attr, char *buf)
247 { 247 {
248 struct damon_sysfs_target *target = co 248 struct damon_sysfs_target *target = container_of(kobj,
249 struct damon_sysfs_tar 249 struct damon_sysfs_target, kobj);
250 250
251 return sysfs_emit(buf, "%d\n", target- 251 return sysfs_emit(buf, "%d\n", target->pid);
252 } 252 }
253 253
254 static ssize_t pid_target_store(struct kobject 254 static ssize_t pid_target_store(struct kobject *kobj,
255 struct kobj_attribute *attr, c 255 struct kobj_attribute *attr, const char *buf, size_t count)
256 { 256 {
257 struct damon_sysfs_target *target = co 257 struct damon_sysfs_target *target = container_of(kobj,
258 struct damon_sysfs_tar 258 struct damon_sysfs_target, kobj);
259 int err = kstrtoint(buf, 0, &target->p 259 int err = kstrtoint(buf, 0, &target->pid);
260 260
261 if (err) 261 if (err)
262 return -EINVAL; 262 return -EINVAL;
263 return count; 263 return count;
264 } 264 }
265 265
266 static void damon_sysfs_target_release(struct 266 static void damon_sysfs_target_release(struct kobject *kobj)
267 { 267 {
268 kfree(container_of(kobj, struct damon_ 268 kfree(container_of(kobj, struct damon_sysfs_target, kobj));
269 } 269 }
270 270
271 static struct kobj_attribute damon_sysfs_targe 271 static struct kobj_attribute damon_sysfs_target_pid_attr =
272 __ATTR_RW_MODE(pid_target, 060 272 __ATTR_RW_MODE(pid_target, 0600);
273 273
274 static struct attribute *damon_sysfs_target_at 274 static struct attribute *damon_sysfs_target_attrs[] = {
275 &damon_sysfs_target_pid_attr.attr, 275 &damon_sysfs_target_pid_attr.attr,
276 NULL, 276 NULL,
277 }; 277 };
278 ATTRIBUTE_GROUPS(damon_sysfs_target); 278 ATTRIBUTE_GROUPS(damon_sysfs_target);
279 279
280 static const struct kobj_type damon_sysfs_targ 280 static const struct kobj_type damon_sysfs_target_ktype = {
281 .release = damon_sysfs_target_release, 281 .release = damon_sysfs_target_release,
282 .sysfs_ops = &kobj_sysfs_ops, 282 .sysfs_ops = &kobj_sysfs_ops,
283 .default_groups = damon_sysfs_target_g 283 .default_groups = damon_sysfs_target_groups,
284 }; 284 };
285 285
286 /* 286 /*
287 * targets directory 287 * targets directory
288 */ 288 */
289 289
290 struct damon_sysfs_targets { 290 struct damon_sysfs_targets {
291 struct kobject kobj; 291 struct kobject kobj;
292 struct damon_sysfs_target **targets_ar 292 struct damon_sysfs_target **targets_arr;
293 int nr; 293 int nr;
294 }; 294 };
295 295
296 static struct damon_sysfs_targets *damon_sysfs 296 static struct damon_sysfs_targets *damon_sysfs_targets_alloc(void)
297 { 297 {
298 return kzalloc(sizeof(struct damon_sys 298 return kzalloc(sizeof(struct damon_sysfs_targets), GFP_KERNEL);
299 } 299 }
300 300
301 static void damon_sysfs_targets_rm_dirs(struct 301 static void damon_sysfs_targets_rm_dirs(struct damon_sysfs_targets *targets)
302 { 302 {
303 struct damon_sysfs_target **targets_ar 303 struct damon_sysfs_target **targets_arr = targets->targets_arr;
304 int i; 304 int i;
305 305
306 for (i = 0; i < targets->nr; i++) { 306 for (i = 0; i < targets->nr; i++) {
307 damon_sysfs_target_rm_dirs(tar 307 damon_sysfs_target_rm_dirs(targets_arr[i]);
308 kobject_put(&targets_arr[i]->k 308 kobject_put(&targets_arr[i]->kobj);
309 } 309 }
310 targets->nr = 0; 310 targets->nr = 0;
311 kfree(targets_arr); 311 kfree(targets_arr);
312 targets->targets_arr = NULL; 312 targets->targets_arr = NULL;
313 } 313 }
314 314
315 static int damon_sysfs_targets_add_dirs(struct 315 static int damon_sysfs_targets_add_dirs(struct damon_sysfs_targets *targets,
316 int nr_targets) 316 int nr_targets)
317 { 317 {
318 struct damon_sysfs_target **targets_ar 318 struct damon_sysfs_target **targets_arr, *target;
319 int err, i; 319 int err, i;
320 320
321 damon_sysfs_targets_rm_dirs(targets); 321 damon_sysfs_targets_rm_dirs(targets);
322 if (!nr_targets) 322 if (!nr_targets)
323 return 0; 323 return 0;
324 324
325 targets_arr = kmalloc_array(nr_targets 325 targets_arr = kmalloc_array(nr_targets, sizeof(*targets_arr),
326 GFP_KERNEL | __GFP_NOW 326 GFP_KERNEL | __GFP_NOWARN);
327 if (!targets_arr) 327 if (!targets_arr)
328 return -ENOMEM; 328 return -ENOMEM;
329 targets->targets_arr = targets_arr; 329 targets->targets_arr = targets_arr;
330 330
331 for (i = 0; i < nr_targets; i++) { 331 for (i = 0; i < nr_targets; i++) {
332 target = damon_sysfs_target_al 332 target = damon_sysfs_target_alloc();
333 if (!target) { 333 if (!target) {
334 damon_sysfs_targets_rm 334 damon_sysfs_targets_rm_dirs(targets);
335 return -ENOMEM; 335 return -ENOMEM;
336 } 336 }
337 337
338 err = kobject_init_and_add(&ta 338 err = kobject_init_and_add(&target->kobj,
339 &damon_sysfs_t 339 &damon_sysfs_target_ktype, &targets->kobj,
340 "%d", i); 340 "%d", i);
341 if (err) 341 if (err)
342 goto out; 342 goto out;
343 343
344 err = damon_sysfs_target_add_d 344 err = damon_sysfs_target_add_dirs(target);
345 if (err) 345 if (err)
346 goto out; 346 goto out;
347 347
348 targets_arr[i] = target; 348 targets_arr[i] = target;
349 targets->nr++; 349 targets->nr++;
350 } 350 }
351 return 0; 351 return 0;
352 352
353 out: 353 out:
354 damon_sysfs_targets_rm_dirs(targets); 354 damon_sysfs_targets_rm_dirs(targets);
355 kobject_put(&target->kobj); 355 kobject_put(&target->kobj);
356 return err; 356 return err;
357 } 357 }
358 358
359 static ssize_t nr_targets_show(struct kobject 359 static ssize_t nr_targets_show(struct kobject *kobj,
360 struct kobj_attribute *attr, c 360 struct kobj_attribute *attr, char *buf)
361 { 361 {
362 struct damon_sysfs_targets *targets = 362 struct damon_sysfs_targets *targets = container_of(kobj,
363 struct damon_sysfs_tar 363 struct damon_sysfs_targets, kobj);
364 364
365 return sysfs_emit(buf, "%d\n", targets 365 return sysfs_emit(buf, "%d\n", targets->nr);
366 } 366 }
367 367
368 static ssize_t nr_targets_store(struct kobject 368 static ssize_t nr_targets_store(struct kobject *kobj,
369 struct kobj_attribute *attr, c 369 struct kobj_attribute *attr, const char *buf, size_t count)
370 { 370 {
371 struct damon_sysfs_targets *targets; 371 struct damon_sysfs_targets *targets;
372 int nr, err = kstrtoint(buf, 0, &nr); 372 int nr, err = kstrtoint(buf, 0, &nr);
373 373
374 if (err) 374 if (err)
375 return err; 375 return err;
376 if (nr < 0) 376 if (nr < 0)
377 return -EINVAL; 377 return -EINVAL;
378 378
379 targets = container_of(kobj, struct da 379 targets = container_of(kobj, struct damon_sysfs_targets, kobj);
380 380
381 if (!mutex_trylock(&damon_sysfs_lock)) 381 if (!mutex_trylock(&damon_sysfs_lock))
382 return -EBUSY; 382 return -EBUSY;
383 err = damon_sysfs_targets_add_dirs(tar 383 err = damon_sysfs_targets_add_dirs(targets, nr);
384 mutex_unlock(&damon_sysfs_lock); 384 mutex_unlock(&damon_sysfs_lock);
385 if (err) 385 if (err)
386 return err; 386 return err;
387 387
388 return count; 388 return count;
389 } 389 }
390 390
391 static void damon_sysfs_targets_release(struct 391 static void damon_sysfs_targets_release(struct kobject *kobj)
392 { 392 {
393 kfree(container_of(kobj, struct damon_ 393 kfree(container_of(kobj, struct damon_sysfs_targets, kobj));
394 } 394 }
395 395
396 static struct kobj_attribute damon_sysfs_targe 396 static struct kobj_attribute damon_sysfs_targets_nr_attr =
397 __ATTR_RW_MODE(nr_targets, 060 397 __ATTR_RW_MODE(nr_targets, 0600);
398 398
399 static struct attribute *damon_sysfs_targets_a 399 static struct attribute *damon_sysfs_targets_attrs[] = {
400 &damon_sysfs_targets_nr_attr.attr, 400 &damon_sysfs_targets_nr_attr.attr,
401 NULL, 401 NULL,
402 }; 402 };
403 ATTRIBUTE_GROUPS(damon_sysfs_targets); 403 ATTRIBUTE_GROUPS(damon_sysfs_targets);
404 404
405 static const struct kobj_type damon_sysfs_targ 405 static const struct kobj_type damon_sysfs_targets_ktype = {
406 .release = damon_sysfs_targets_release 406 .release = damon_sysfs_targets_release,
407 .sysfs_ops = &kobj_sysfs_ops, 407 .sysfs_ops = &kobj_sysfs_ops,
408 .default_groups = damon_sysfs_targets_ 408 .default_groups = damon_sysfs_targets_groups,
409 }; 409 };
410 410
411 /* 411 /*
412 * intervals directory 412 * intervals directory
413 */ 413 */
414 414
415 struct damon_sysfs_intervals { 415 struct damon_sysfs_intervals {
416 struct kobject kobj; 416 struct kobject kobj;
417 unsigned long sample_us; 417 unsigned long sample_us;
418 unsigned long aggr_us; 418 unsigned long aggr_us;
419 unsigned long update_us; 419 unsigned long update_us;
420 }; 420 };
421 421
422 static struct damon_sysfs_intervals *damon_sys 422 static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc(
423 unsigned long sample_us, unsig 423 unsigned long sample_us, unsigned long aggr_us,
424 unsigned long update_us) 424 unsigned long update_us)
425 { 425 {
426 struct damon_sysfs_intervals *interval 426 struct damon_sysfs_intervals *intervals = kmalloc(sizeof(*intervals),
427 GFP_KERNEL); 427 GFP_KERNEL);
428 428
429 if (!intervals) 429 if (!intervals)
430 return NULL; 430 return NULL;
431 431
432 intervals->kobj = (struct kobject){}; 432 intervals->kobj = (struct kobject){};
433 intervals->sample_us = sample_us; 433 intervals->sample_us = sample_us;
434 intervals->aggr_us = aggr_us; 434 intervals->aggr_us = aggr_us;
435 intervals->update_us = update_us; 435 intervals->update_us = update_us;
436 return intervals; 436 return intervals;
437 } 437 }
438 438
439 static ssize_t sample_us_show(struct kobject * 439 static ssize_t sample_us_show(struct kobject *kobj,
440 struct kobj_attribute *attr, c 440 struct kobj_attribute *attr, char *buf)
441 { 441 {
442 struct damon_sysfs_intervals *interval 442 struct damon_sysfs_intervals *intervals = container_of(kobj,
443 struct damon_sysfs_int 443 struct damon_sysfs_intervals, kobj);
444 444
445 return sysfs_emit(buf, "%lu\n", interv 445 return sysfs_emit(buf, "%lu\n", intervals->sample_us);
446 } 446 }
447 447
448 static ssize_t sample_us_store(struct kobject 448 static ssize_t sample_us_store(struct kobject *kobj,
449 struct kobj_attribute *attr, c 449 struct kobj_attribute *attr, const char *buf, size_t count)
450 { 450 {
451 struct damon_sysfs_intervals *interval 451 struct damon_sysfs_intervals *intervals = container_of(kobj,
452 struct damon_sysfs_int 452 struct damon_sysfs_intervals, kobj);
453 unsigned long us; 453 unsigned long us;
454 int err = kstrtoul(buf, 0, &us); 454 int err = kstrtoul(buf, 0, &us);
455 455
456 if (err) 456 if (err)
457 return err; 457 return err;
458 458
459 intervals->sample_us = us; 459 intervals->sample_us = us;
460 return count; 460 return count;
461 } 461 }
462 462
463 static ssize_t aggr_us_show(struct kobject *ko 463 static ssize_t aggr_us_show(struct kobject *kobj, struct kobj_attribute *attr,
464 char *buf) 464 char *buf)
465 { 465 {
466 struct damon_sysfs_intervals *interval 466 struct damon_sysfs_intervals *intervals = container_of(kobj,
467 struct damon_sysfs_int 467 struct damon_sysfs_intervals, kobj);
468 468
469 return sysfs_emit(buf, "%lu\n", interv 469 return sysfs_emit(buf, "%lu\n", intervals->aggr_us);
470 } 470 }
471 471
472 static ssize_t aggr_us_store(struct kobject *k 472 static ssize_t aggr_us_store(struct kobject *kobj, struct kobj_attribute *attr,
473 const char *buf, size_t count) 473 const char *buf, size_t count)
474 { 474 {
475 struct damon_sysfs_intervals *interval 475 struct damon_sysfs_intervals *intervals = container_of(kobj,
476 struct damon_sysfs_int 476 struct damon_sysfs_intervals, kobj);
477 unsigned long us; 477 unsigned long us;
478 int err = kstrtoul(buf, 0, &us); 478 int err = kstrtoul(buf, 0, &us);
479 479
480 if (err) 480 if (err)
481 return err; 481 return err;
482 482
483 intervals->aggr_us = us; 483 intervals->aggr_us = us;
484 return count; 484 return count;
485 } 485 }
486 486
487 static ssize_t update_us_show(struct kobject * 487 static ssize_t update_us_show(struct kobject *kobj,
488 struct kobj_attribute *attr, c 488 struct kobj_attribute *attr, char *buf)
489 { 489 {
490 struct damon_sysfs_intervals *interval 490 struct damon_sysfs_intervals *intervals = container_of(kobj,
491 struct damon_sysfs_int 491 struct damon_sysfs_intervals, kobj);
492 492
493 return sysfs_emit(buf, "%lu\n", interv 493 return sysfs_emit(buf, "%lu\n", intervals->update_us);
494 } 494 }
495 495
496 static ssize_t update_us_store(struct kobject 496 static ssize_t update_us_store(struct kobject *kobj,
497 struct kobj_attribute *attr, c 497 struct kobj_attribute *attr, const char *buf, size_t count)
498 { 498 {
499 struct damon_sysfs_intervals *interval 499 struct damon_sysfs_intervals *intervals = container_of(kobj,
500 struct damon_sysfs_int 500 struct damon_sysfs_intervals, kobj);
501 unsigned long us; 501 unsigned long us;
502 int err = kstrtoul(buf, 0, &us); 502 int err = kstrtoul(buf, 0, &us);
503 503
504 if (err) 504 if (err)
505 return err; 505 return err;
506 506
507 intervals->update_us = us; 507 intervals->update_us = us;
508 return count; 508 return count;
509 } 509 }
510 510
511 static void damon_sysfs_intervals_release(stru 511 static void damon_sysfs_intervals_release(struct kobject *kobj)
512 { 512 {
513 kfree(container_of(kobj, struct damon_ 513 kfree(container_of(kobj, struct damon_sysfs_intervals, kobj));
514 } 514 }
515 515
516 static struct kobj_attribute damon_sysfs_inter 516 static struct kobj_attribute damon_sysfs_intervals_sample_us_attr =
517 __ATTR_RW_MODE(sample_us, 0600 517 __ATTR_RW_MODE(sample_us, 0600);
518 518
519 static struct kobj_attribute damon_sysfs_inter 519 static struct kobj_attribute damon_sysfs_intervals_aggr_us_attr =
520 __ATTR_RW_MODE(aggr_us, 0600); 520 __ATTR_RW_MODE(aggr_us, 0600);
521 521
522 static struct kobj_attribute damon_sysfs_inter 522 static struct kobj_attribute damon_sysfs_intervals_update_us_attr =
523 __ATTR_RW_MODE(update_us, 0600 523 __ATTR_RW_MODE(update_us, 0600);
524 524
525 static struct attribute *damon_sysfs_intervals 525 static struct attribute *damon_sysfs_intervals_attrs[] = {
526 &damon_sysfs_intervals_sample_us_attr. 526 &damon_sysfs_intervals_sample_us_attr.attr,
527 &damon_sysfs_intervals_aggr_us_attr.at 527 &damon_sysfs_intervals_aggr_us_attr.attr,
528 &damon_sysfs_intervals_update_us_attr. 528 &damon_sysfs_intervals_update_us_attr.attr,
529 NULL, 529 NULL,
530 }; 530 };
531 ATTRIBUTE_GROUPS(damon_sysfs_intervals); 531 ATTRIBUTE_GROUPS(damon_sysfs_intervals);
532 532
533 static const struct kobj_type damon_sysfs_inte 533 static const struct kobj_type damon_sysfs_intervals_ktype = {
534 .release = damon_sysfs_intervals_relea 534 .release = damon_sysfs_intervals_release,
535 .sysfs_ops = &kobj_sysfs_ops, 535 .sysfs_ops = &kobj_sysfs_ops,
536 .default_groups = damon_sysfs_interval 536 .default_groups = damon_sysfs_intervals_groups,
537 }; 537 };
538 538
539 /* 539 /*
540 * monitoring_attrs directory 540 * monitoring_attrs directory
541 */ 541 */
542 542
543 struct damon_sysfs_attrs { 543 struct damon_sysfs_attrs {
544 struct kobject kobj; 544 struct kobject kobj;
545 struct damon_sysfs_intervals *interval 545 struct damon_sysfs_intervals *intervals;
546 struct damon_sysfs_ul_range *nr_region 546 struct damon_sysfs_ul_range *nr_regions_range;
547 }; 547 };
548 548
549 static struct damon_sysfs_attrs *damon_sysfs_a 549 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void)
550 { 550 {
551 struct damon_sysfs_attrs *attrs = kmal 551 struct damon_sysfs_attrs *attrs = kmalloc(sizeof(*attrs), GFP_KERNEL);
552 552
553 if (!attrs) 553 if (!attrs)
554 return NULL; 554 return NULL;
555 attrs->kobj = (struct kobject){}; 555 attrs->kobj = (struct kobject){};
556 return attrs; 556 return attrs;
557 } 557 }
558 558
559 static int damon_sysfs_attrs_add_dirs(struct d 559 static int damon_sysfs_attrs_add_dirs(struct damon_sysfs_attrs *attrs)
560 { 560 {
561 struct damon_sysfs_intervals *interval 561 struct damon_sysfs_intervals *intervals;
562 struct damon_sysfs_ul_range *nr_region 562 struct damon_sysfs_ul_range *nr_regions_range;
563 int err; 563 int err;
564 564
565 intervals = damon_sysfs_intervals_allo 565 intervals = damon_sysfs_intervals_alloc(5000, 100000, 60000000);
566 if (!intervals) 566 if (!intervals)
567 return -ENOMEM; 567 return -ENOMEM;
568 568
569 err = kobject_init_and_add(&intervals- 569 err = kobject_init_and_add(&intervals->kobj,
570 &damon_sysfs_intervals 570 &damon_sysfs_intervals_ktype, &attrs->kobj,
571 "intervals"); 571 "intervals");
572 if (err) 572 if (err)
573 goto put_intervals_out; 573 goto put_intervals_out;
574 attrs->intervals = intervals; 574 attrs->intervals = intervals;
575 575
576 nr_regions_range = damon_sysfs_ul_rang 576 nr_regions_range = damon_sysfs_ul_range_alloc(10, 1000);
577 if (!nr_regions_range) { 577 if (!nr_regions_range) {
578 err = -ENOMEM; 578 err = -ENOMEM;
579 goto put_intervals_out; 579 goto put_intervals_out;
580 } 580 }
581 581
582 err = kobject_init_and_add(&nr_regions 582 err = kobject_init_and_add(&nr_regions_range->kobj,
583 &damon_sysfs_ul_range_ 583 &damon_sysfs_ul_range_ktype, &attrs->kobj,
584 "nr_regions"); 584 "nr_regions");
585 if (err) 585 if (err)
586 goto put_nr_regions_intervals_ 586 goto put_nr_regions_intervals_out;
587 attrs->nr_regions_range = nr_regions_r 587 attrs->nr_regions_range = nr_regions_range;
588 return 0; 588 return 0;
589 589
590 put_nr_regions_intervals_out: 590 put_nr_regions_intervals_out:
591 kobject_put(&nr_regions_range->kobj); 591 kobject_put(&nr_regions_range->kobj);
592 attrs->nr_regions_range = NULL; 592 attrs->nr_regions_range = NULL;
593 put_intervals_out: 593 put_intervals_out:
594 kobject_put(&intervals->kobj); 594 kobject_put(&intervals->kobj);
595 attrs->intervals = NULL; 595 attrs->intervals = NULL;
596 return err; 596 return err;
597 } 597 }
598 598
599 static void damon_sysfs_attrs_rm_dirs(struct d 599 static void damon_sysfs_attrs_rm_dirs(struct damon_sysfs_attrs *attrs)
600 { 600 {
601 kobject_put(&attrs->nr_regions_range-> 601 kobject_put(&attrs->nr_regions_range->kobj);
602 kobject_put(&attrs->intervals->kobj); 602 kobject_put(&attrs->intervals->kobj);
603 } 603 }
604 604
605 static void damon_sysfs_attrs_release(struct k 605 static void damon_sysfs_attrs_release(struct kobject *kobj)
606 { 606 {
607 kfree(container_of(kobj, struct damon_ 607 kfree(container_of(kobj, struct damon_sysfs_attrs, kobj));
608 } 608 }
609 609
610 static struct attribute *damon_sysfs_attrs_att 610 static struct attribute *damon_sysfs_attrs_attrs[] = {
611 NULL, 611 NULL,
612 }; 612 };
613 ATTRIBUTE_GROUPS(damon_sysfs_attrs); 613 ATTRIBUTE_GROUPS(damon_sysfs_attrs);
614 614
615 static const struct kobj_type damon_sysfs_attr 615 static const struct kobj_type damon_sysfs_attrs_ktype = {
616 .release = damon_sysfs_attrs_release, 616 .release = damon_sysfs_attrs_release,
617 .sysfs_ops = &kobj_sysfs_ops, 617 .sysfs_ops = &kobj_sysfs_ops,
618 .default_groups = damon_sysfs_attrs_gr 618 .default_groups = damon_sysfs_attrs_groups,
619 }; 619 };
620 620
621 /* 621 /*
622 * context directory 622 * context directory
623 */ 623 */
624 624
625 /* This should match with enum damon_ops_id */ 625 /* This should match with enum damon_ops_id */
626 static const char * const damon_sysfs_ops_strs 626 static const char * const damon_sysfs_ops_strs[] = {
627 "vaddr", 627 "vaddr",
628 "fvaddr", 628 "fvaddr",
629 "paddr", 629 "paddr",
630 }; 630 };
631 631
632 struct damon_sysfs_context { 632 struct damon_sysfs_context {
633 struct kobject kobj; 633 struct kobject kobj;
634 enum damon_ops_id ops_id; 634 enum damon_ops_id ops_id;
635 struct damon_sysfs_attrs *attrs; 635 struct damon_sysfs_attrs *attrs;
636 struct damon_sysfs_targets *targets; 636 struct damon_sysfs_targets *targets;
637 struct damon_sysfs_schemes *schemes; 637 struct damon_sysfs_schemes *schemes;
638 }; 638 };
639 639
640 static struct damon_sysfs_context *damon_sysfs 640 static struct damon_sysfs_context *damon_sysfs_context_alloc(
641 enum damon_ops_id ops_id) 641 enum damon_ops_id ops_id)
642 { 642 {
643 struct damon_sysfs_context *context = 643 struct damon_sysfs_context *context = kmalloc(sizeof(*context),
644 GFP_KERNEL); 644 GFP_KERNEL);
645 645
646 if (!context) 646 if (!context)
647 return NULL; 647 return NULL;
648 context->kobj = (struct kobject){}; 648 context->kobj = (struct kobject){};
649 context->ops_id = ops_id; 649 context->ops_id = ops_id;
650 return context; 650 return context;
651 } 651 }
652 652
653 static int damon_sysfs_context_set_attrs(struc 653 static int damon_sysfs_context_set_attrs(struct damon_sysfs_context *context)
654 { 654 {
655 struct damon_sysfs_attrs *attrs = damo 655 struct damon_sysfs_attrs *attrs = damon_sysfs_attrs_alloc();
656 int err; 656 int err;
657 657
658 if (!attrs) 658 if (!attrs)
659 return -ENOMEM; 659 return -ENOMEM;
660 err = kobject_init_and_add(&attrs->kob 660 err = kobject_init_and_add(&attrs->kobj, &damon_sysfs_attrs_ktype,
661 &context->kobj, "monit 661 &context->kobj, "monitoring_attrs");
662 if (err) 662 if (err)
663 goto out; 663 goto out;
664 err = damon_sysfs_attrs_add_dirs(attrs 664 err = damon_sysfs_attrs_add_dirs(attrs);
665 if (err) 665 if (err)
666 goto out; 666 goto out;
667 context->attrs = attrs; 667 context->attrs = attrs;
668 return 0; 668 return 0;
669 669
670 out: 670 out:
671 kobject_put(&attrs->kobj); 671 kobject_put(&attrs->kobj);
672 return err; 672 return err;
673 } 673 }
674 674
675 static int damon_sysfs_context_set_targets(str 675 static int damon_sysfs_context_set_targets(struct damon_sysfs_context *context)
676 { 676 {
677 struct damon_sysfs_targets *targets = 677 struct damon_sysfs_targets *targets = damon_sysfs_targets_alloc();
678 int err; 678 int err;
679 679
680 if (!targets) 680 if (!targets)
681 return -ENOMEM; 681 return -ENOMEM;
682 err = kobject_init_and_add(&targets->k 682 err = kobject_init_and_add(&targets->kobj, &damon_sysfs_targets_ktype,
683 &context->kobj, "targe 683 &context->kobj, "targets");
684 if (err) { 684 if (err) {
685 kobject_put(&targets->kobj); 685 kobject_put(&targets->kobj);
686 return err; 686 return err;
687 } 687 }
688 context->targets = targets; 688 context->targets = targets;
689 return 0; 689 return 0;
690 } 690 }
691 691
692 static int damon_sysfs_context_set_schemes(str 692 static int damon_sysfs_context_set_schemes(struct damon_sysfs_context *context)
693 { 693 {
694 struct damon_sysfs_schemes *schemes = 694 struct damon_sysfs_schemes *schemes = damon_sysfs_schemes_alloc();
695 int err; 695 int err;
696 696
697 if (!schemes) 697 if (!schemes)
698 return -ENOMEM; 698 return -ENOMEM;
699 err = kobject_init_and_add(&schemes->k 699 err = kobject_init_and_add(&schemes->kobj, &damon_sysfs_schemes_ktype,
700 &context->kobj, "schem 700 &context->kobj, "schemes");
701 if (err) { 701 if (err) {
702 kobject_put(&schemes->kobj); 702 kobject_put(&schemes->kobj);
703 return err; 703 return err;
704 } 704 }
705 context->schemes = schemes; 705 context->schemes = schemes;
706 return 0; 706 return 0;
707 } 707 }
708 708
709 static int damon_sysfs_context_add_dirs(struct 709 static int damon_sysfs_context_add_dirs(struct damon_sysfs_context *context)
710 { 710 {
711 int err; 711 int err;
712 712
713 err = damon_sysfs_context_set_attrs(co 713 err = damon_sysfs_context_set_attrs(context);
714 if (err) 714 if (err)
715 return err; 715 return err;
716 716
717 err = damon_sysfs_context_set_targets( 717 err = damon_sysfs_context_set_targets(context);
718 if (err) 718 if (err)
719 goto put_attrs_out; 719 goto put_attrs_out;
720 720
721 err = damon_sysfs_context_set_schemes( 721 err = damon_sysfs_context_set_schemes(context);
722 if (err) 722 if (err)
723 goto put_targets_attrs_out; 723 goto put_targets_attrs_out;
724 return 0; 724 return 0;
725 725
726 put_targets_attrs_out: 726 put_targets_attrs_out:
727 kobject_put(&context->targets->kobj); 727 kobject_put(&context->targets->kobj);
728 context->targets = NULL; 728 context->targets = NULL;
729 put_attrs_out: 729 put_attrs_out:
730 kobject_put(&context->attrs->kobj); 730 kobject_put(&context->attrs->kobj);
731 context->attrs = NULL; 731 context->attrs = NULL;
732 return err; 732 return err;
733 } 733 }
734 734
735 static void damon_sysfs_context_rm_dirs(struct 735 static void damon_sysfs_context_rm_dirs(struct damon_sysfs_context *context)
736 { 736 {
737 damon_sysfs_attrs_rm_dirs(context->att 737 damon_sysfs_attrs_rm_dirs(context->attrs);
738 kobject_put(&context->attrs->kobj); 738 kobject_put(&context->attrs->kobj);
739 damon_sysfs_targets_rm_dirs(context->t 739 damon_sysfs_targets_rm_dirs(context->targets);
740 kobject_put(&context->targets->kobj); 740 kobject_put(&context->targets->kobj);
741 damon_sysfs_schemes_rm_dirs(context->s 741 damon_sysfs_schemes_rm_dirs(context->schemes);
742 kobject_put(&context->schemes->kobj); 742 kobject_put(&context->schemes->kobj);
743 } 743 }
744 744
745 static ssize_t avail_operations_show(struct ko 745 static ssize_t avail_operations_show(struct kobject *kobj,
746 struct kobj_attribute *attr, c 746 struct kobj_attribute *attr, char *buf)
747 { 747 {
748 enum damon_ops_id id; 748 enum damon_ops_id id;
749 int len = 0; 749 int len = 0;
750 750
751 for (id = 0; id < NR_DAMON_OPS; id++) 751 for (id = 0; id < NR_DAMON_OPS; id++) {
752 if (!damon_is_registered_ops(i 752 if (!damon_is_registered_ops(id))
753 continue; 753 continue;
754 len += sysfs_emit_at(buf, len, 754 len += sysfs_emit_at(buf, len, "%s\n",
755 damon_sysfs_op 755 damon_sysfs_ops_strs[id]);
756 } 756 }
757 return len; 757 return len;
758 } 758 }
759 759
760 static ssize_t operations_show(struct kobject 760 static ssize_t operations_show(struct kobject *kobj,
761 struct kobj_attribute *attr, c 761 struct kobj_attribute *attr, char *buf)
762 { 762 {
763 struct damon_sysfs_context *context = 763 struct damon_sysfs_context *context = container_of(kobj,
764 struct damon_sysfs_con 764 struct damon_sysfs_context, kobj);
765 765
766 return sysfs_emit(buf, "%s\n", damon_s 766 return sysfs_emit(buf, "%s\n", damon_sysfs_ops_strs[context->ops_id]);
767 } 767 }
768 768
769 static ssize_t operations_store(struct kobject 769 static ssize_t operations_store(struct kobject *kobj,
770 struct kobj_attribute *attr, c 770 struct kobj_attribute *attr, const char *buf, size_t count)
771 { 771 {
772 struct damon_sysfs_context *context = 772 struct damon_sysfs_context *context = container_of(kobj,
773 struct damon_sysfs_con 773 struct damon_sysfs_context, kobj);
774 enum damon_ops_id id; 774 enum damon_ops_id id;
775 775
776 for (id = 0; id < NR_DAMON_OPS; id++) 776 for (id = 0; id < NR_DAMON_OPS; id++) {
777 if (sysfs_streq(buf, damon_sys 777 if (sysfs_streq(buf, damon_sysfs_ops_strs[id])) {
778 context->ops_id = id; 778 context->ops_id = id;
779 return count; 779 return count;
780 } 780 }
781 } 781 }
782 return -EINVAL; 782 return -EINVAL;
783 } 783 }
784 784
785 static void damon_sysfs_context_release(struct 785 static void damon_sysfs_context_release(struct kobject *kobj)
786 { 786 {
787 kfree(container_of(kobj, struct damon_ 787 kfree(container_of(kobj, struct damon_sysfs_context, kobj));
788 } 788 }
789 789
790 static struct kobj_attribute damon_sysfs_conte 790 static struct kobj_attribute damon_sysfs_context_avail_operations_attr =
791 __ATTR_RO_MODE(avail_operation 791 __ATTR_RO_MODE(avail_operations, 0400);
792 792
793 static struct kobj_attribute damon_sysfs_conte 793 static struct kobj_attribute damon_sysfs_context_operations_attr =
794 __ATTR_RW_MODE(operations, 060 794 __ATTR_RW_MODE(operations, 0600);
795 795
796 static struct attribute *damon_sysfs_context_a 796 static struct attribute *damon_sysfs_context_attrs[] = {
797 &damon_sysfs_context_avail_operations_ 797 &damon_sysfs_context_avail_operations_attr.attr,
798 &damon_sysfs_context_operations_attr.a 798 &damon_sysfs_context_operations_attr.attr,
799 NULL, 799 NULL,
800 }; 800 };
801 ATTRIBUTE_GROUPS(damon_sysfs_context); 801 ATTRIBUTE_GROUPS(damon_sysfs_context);
802 802
803 static const struct kobj_type damon_sysfs_cont 803 static const struct kobj_type damon_sysfs_context_ktype = {
804 .release = damon_sysfs_context_release 804 .release = damon_sysfs_context_release,
805 .sysfs_ops = &kobj_sysfs_ops, 805 .sysfs_ops = &kobj_sysfs_ops,
806 .default_groups = damon_sysfs_context_ 806 .default_groups = damon_sysfs_context_groups,
807 }; 807 };
808 808
809 /* 809 /*
810 * contexts directory 810 * contexts directory
811 */ 811 */
812 812
813 struct damon_sysfs_contexts { 813 struct damon_sysfs_contexts {
814 struct kobject kobj; 814 struct kobject kobj;
815 struct damon_sysfs_context **contexts_ 815 struct damon_sysfs_context **contexts_arr;
816 int nr; 816 int nr;
817 }; 817 };
818 818
819 static struct damon_sysfs_contexts *damon_sysf 819 static struct damon_sysfs_contexts *damon_sysfs_contexts_alloc(void)
820 { 820 {
821 return kzalloc(sizeof(struct damon_sys 821 return kzalloc(sizeof(struct damon_sysfs_contexts), GFP_KERNEL);
822 } 822 }
823 823
824 static void damon_sysfs_contexts_rm_dirs(struc 824 static void damon_sysfs_contexts_rm_dirs(struct damon_sysfs_contexts *contexts)
825 { 825 {
826 struct damon_sysfs_context **contexts_ 826 struct damon_sysfs_context **contexts_arr = contexts->contexts_arr;
827 int i; 827 int i;
828 828
829 for (i = 0; i < contexts->nr; i++) { 829 for (i = 0; i < contexts->nr; i++) {
830 damon_sysfs_context_rm_dirs(co 830 damon_sysfs_context_rm_dirs(contexts_arr[i]);
831 kobject_put(&contexts_arr[i]-> 831 kobject_put(&contexts_arr[i]->kobj);
832 } 832 }
833 contexts->nr = 0; 833 contexts->nr = 0;
834 kfree(contexts_arr); 834 kfree(contexts_arr);
835 contexts->contexts_arr = NULL; 835 contexts->contexts_arr = NULL;
836 } 836 }
837 837
838 static int damon_sysfs_contexts_add_dirs(struc 838 static int damon_sysfs_contexts_add_dirs(struct damon_sysfs_contexts *contexts,
839 int nr_contexts) 839 int nr_contexts)
840 { 840 {
841 struct damon_sysfs_context **contexts_ 841 struct damon_sysfs_context **contexts_arr, *context;
842 int err, i; 842 int err, i;
843 843
844 damon_sysfs_contexts_rm_dirs(contexts) 844 damon_sysfs_contexts_rm_dirs(contexts);
845 if (!nr_contexts) 845 if (!nr_contexts)
846 return 0; 846 return 0;
847 847
848 contexts_arr = kmalloc_array(nr_contex 848 contexts_arr = kmalloc_array(nr_contexts, sizeof(*contexts_arr),
849 GFP_KERNEL | __GFP_NOW 849 GFP_KERNEL | __GFP_NOWARN);
850 if (!contexts_arr) 850 if (!contexts_arr)
851 return -ENOMEM; 851 return -ENOMEM;
852 contexts->contexts_arr = contexts_arr; 852 contexts->contexts_arr = contexts_arr;
853 853
854 for (i = 0; i < nr_contexts; i++) { 854 for (i = 0; i < nr_contexts; i++) {
855 context = damon_sysfs_context_ 855 context = damon_sysfs_context_alloc(DAMON_OPS_VADDR);
856 if (!context) { 856 if (!context) {
857 damon_sysfs_contexts_r 857 damon_sysfs_contexts_rm_dirs(contexts);
858 return -ENOMEM; 858 return -ENOMEM;
859 } 859 }
860 860
861 err = kobject_init_and_add(&co 861 err = kobject_init_and_add(&context->kobj,
862 &damon_sysfs_c 862 &damon_sysfs_context_ktype, &contexts->kobj,
863 "%d", i); 863 "%d", i);
864 if (err) 864 if (err)
865 goto out; 865 goto out;
866 866
867 err = damon_sysfs_context_add_ 867 err = damon_sysfs_context_add_dirs(context);
868 if (err) 868 if (err)
869 goto out; 869 goto out;
870 870
871 contexts_arr[i] = context; 871 contexts_arr[i] = context;
872 contexts->nr++; 872 contexts->nr++;
873 } 873 }
874 return 0; 874 return 0;
875 875
876 out: 876 out:
877 damon_sysfs_contexts_rm_dirs(contexts) 877 damon_sysfs_contexts_rm_dirs(contexts);
878 kobject_put(&context->kobj); 878 kobject_put(&context->kobj);
879 return err; 879 return err;
880 } 880 }
881 881
882 static ssize_t nr_contexts_show(struct kobject 882 static ssize_t nr_contexts_show(struct kobject *kobj,
883 struct kobj_attribute *attr, c 883 struct kobj_attribute *attr, char *buf)
884 { 884 {
885 struct damon_sysfs_contexts *contexts 885 struct damon_sysfs_contexts *contexts = container_of(kobj,
886 struct damon_sysfs_con 886 struct damon_sysfs_contexts, kobj);
887 887
888 return sysfs_emit(buf, "%d\n", context 888 return sysfs_emit(buf, "%d\n", contexts->nr);
889 } 889 }
890 890
891 static ssize_t nr_contexts_store(struct kobjec 891 static ssize_t nr_contexts_store(struct kobject *kobj,
892 struct kobj_attribute *attr, c 892 struct kobj_attribute *attr, const char *buf, size_t count)
893 { 893 {
894 struct damon_sysfs_contexts *contexts; 894 struct damon_sysfs_contexts *contexts;
895 int nr, err; 895 int nr, err;
896 896
897 err = kstrtoint(buf, 0, &nr); 897 err = kstrtoint(buf, 0, &nr);
898 if (err) 898 if (err)
899 return err; 899 return err;
900 /* TODO: support multiple contexts per 900 /* TODO: support multiple contexts per kdamond */
901 if (nr < 0 || 1 < nr) 901 if (nr < 0 || 1 < nr)
902 return -EINVAL; 902 return -EINVAL;
903 903
904 contexts = container_of(kobj, struct d 904 contexts = container_of(kobj, struct damon_sysfs_contexts, kobj);
905 if (!mutex_trylock(&damon_sysfs_lock)) 905 if (!mutex_trylock(&damon_sysfs_lock))
906 return -EBUSY; 906 return -EBUSY;
907 err = damon_sysfs_contexts_add_dirs(co 907 err = damon_sysfs_contexts_add_dirs(contexts, nr);
908 mutex_unlock(&damon_sysfs_lock); 908 mutex_unlock(&damon_sysfs_lock);
909 if (err) 909 if (err)
910 return err; 910 return err;
911 911
912 return count; 912 return count;
913 } 913 }
914 914
915 static void damon_sysfs_contexts_release(struc 915 static void damon_sysfs_contexts_release(struct kobject *kobj)
916 { 916 {
917 kfree(container_of(kobj, struct damon_ 917 kfree(container_of(kobj, struct damon_sysfs_contexts, kobj));
918 } 918 }
919 919
920 static struct kobj_attribute damon_sysfs_conte 920 static struct kobj_attribute damon_sysfs_contexts_nr_attr
921 = __ATTR_RW_MODE(nr_contexts, 921 = __ATTR_RW_MODE(nr_contexts, 0600);
922 922
923 static struct attribute *damon_sysfs_contexts_ 923 static struct attribute *damon_sysfs_contexts_attrs[] = {
924 &damon_sysfs_contexts_nr_attr.attr, 924 &damon_sysfs_contexts_nr_attr.attr,
925 NULL, 925 NULL,
926 }; 926 };
927 ATTRIBUTE_GROUPS(damon_sysfs_contexts); 927 ATTRIBUTE_GROUPS(damon_sysfs_contexts);
928 928
929 static const struct kobj_type damon_sysfs_cont 929 static const struct kobj_type damon_sysfs_contexts_ktype = {
930 .release = damon_sysfs_contexts_releas 930 .release = damon_sysfs_contexts_release,
931 .sysfs_ops = &kobj_sysfs_ops, 931 .sysfs_ops = &kobj_sysfs_ops,
932 .default_groups = damon_sysfs_contexts 932 .default_groups = damon_sysfs_contexts_groups,
933 }; 933 };
934 934
935 /* 935 /*
936 * kdamond directory 936 * kdamond directory
937 */ 937 */
938 938
939 struct damon_sysfs_kdamond { 939 struct damon_sysfs_kdamond {
940 struct kobject kobj; 940 struct kobject kobj;
941 struct damon_sysfs_contexts *contexts; 941 struct damon_sysfs_contexts *contexts;
942 struct damon_ctx *damon_ctx; 942 struct damon_ctx *damon_ctx;
943 }; 943 };
944 944
945 static struct damon_sysfs_kdamond *damon_sysfs 945 static struct damon_sysfs_kdamond *damon_sysfs_kdamond_alloc(void)
946 { 946 {
947 return kzalloc(sizeof(struct damon_sys 947 return kzalloc(sizeof(struct damon_sysfs_kdamond), GFP_KERNEL);
948 } 948 }
949 949
950 static int damon_sysfs_kdamond_add_dirs(struct 950 static int damon_sysfs_kdamond_add_dirs(struct damon_sysfs_kdamond *kdamond)
951 { 951 {
952 struct damon_sysfs_contexts *contexts; 952 struct damon_sysfs_contexts *contexts;
953 int err; 953 int err;
954 954
955 contexts = damon_sysfs_contexts_alloc( 955 contexts = damon_sysfs_contexts_alloc();
956 if (!contexts) 956 if (!contexts)
957 return -ENOMEM; 957 return -ENOMEM;
958 958
959 err = kobject_init_and_add(&contexts-> 959 err = kobject_init_and_add(&contexts->kobj,
960 &damon_sysfs_contexts_ 960 &damon_sysfs_contexts_ktype, &kdamond->kobj,
961 "contexts"); 961 "contexts");
962 if (err) { 962 if (err) {
963 kobject_put(&contexts->kobj); 963 kobject_put(&contexts->kobj);
964 return err; 964 return err;
965 } 965 }
966 kdamond->contexts = contexts; 966 kdamond->contexts = contexts;
967 967
968 return err; 968 return err;
969 } 969 }
970 970
971 static void damon_sysfs_kdamond_rm_dirs(struct 971 static void damon_sysfs_kdamond_rm_dirs(struct damon_sysfs_kdamond *kdamond)
972 { 972 {
973 damon_sysfs_contexts_rm_dirs(kdamond-> 973 damon_sysfs_contexts_rm_dirs(kdamond->contexts);
974 kobject_put(&kdamond->contexts->kobj); 974 kobject_put(&kdamond->contexts->kobj);
975 } 975 }
976 976
977 static bool damon_sysfs_ctx_running(struct dam 977 static bool damon_sysfs_ctx_running(struct damon_ctx *ctx)
978 { 978 {
979 bool running; 979 bool running;
980 980
981 mutex_lock(&ctx->kdamond_lock); 981 mutex_lock(&ctx->kdamond_lock);
982 running = ctx->kdamond != NULL; 982 running = ctx->kdamond != NULL;
983 mutex_unlock(&ctx->kdamond_lock); 983 mutex_unlock(&ctx->kdamond_lock);
984 return running; 984 return running;
985 } 985 }
986 986
987 /* 987 /*
988 * enum damon_sysfs_cmd - Commands for a speci 988 * enum damon_sysfs_cmd - Commands for a specific kdamond.
989 */ 989 */
990 enum damon_sysfs_cmd { 990 enum damon_sysfs_cmd {
991 /* @DAMON_SYSFS_CMD_ON: Turn the kdamo 991 /* @DAMON_SYSFS_CMD_ON: Turn the kdamond on. */
992 DAMON_SYSFS_CMD_ON, 992 DAMON_SYSFS_CMD_ON,
993 /* @DAMON_SYSFS_CMD_OFF: Turn the kdam 993 /* @DAMON_SYSFS_CMD_OFF: Turn the kdamond off. */
994 DAMON_SYSFS_CMD_OFF, 994 DAMON_SYSFS_CMD_OFF,
995 /* @DAMON_SYSFS_CMD_COMMIT: Update kda 995 /* @DAMON_SYSFS_CMD_COMMIT: Update kdamond inputs. */
996 DAMON_SYSFS_CMD_COMMIT, 996 DAMON_SYSFS_CMD_COMMIT,
997 /* 997 /*
998 * @DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUO <<
999 * to DAMON. <<
1000 */ <<
1001 DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_ <<
1002 /* <<
1003 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_ST 998 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: Update scheme stats sysfs
1004 * files. 999 * files.
1005 */ 1000 */
1006 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS, 1001 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS,
1007 /* 1002 /*
1008 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TR <<
1009 * tried_regions/total_bytes sysfs fi <<
1010 */ <<
1011 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_ <<
1012 /* <<
1013 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TR 1003 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried
1014 * regions 1004 * regions
1015 */ 1005 */
1016 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_ 1006 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS,
1017 /* 1007 /*
1018 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRI 1008 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried
1019 * regions 1009 * regions
1020 */ 1010 */
1021 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_R 1011 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS,
1022 /* 1012 /*
1023 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_EF <<
1024 * effective size quota of the scheme <<
1025 */ <<
1026 DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECT <<
1027 /* <<
1028 * @NR_DAMON_SYSFS_CMDS: Total number 1013 * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands.
1029 */ 1014 */
1030 NR_DAMON_SYSFS_CMDS, 1015 NR_DAMON_SYSFS_CMDS,
1031 }; 1016 };
1032 1017
1033 /* Should match with enum damon_sysfs_cmd */ 1018 /* Should match with enum damon_sysfs_cmd */
1034 static const char * const damon_sysfs_cmd_str 1019 static const char * const damon_sysfs_cmd_strs[] = {
1035 "on", 1020 "on",
1036 "off", 1021 "off",
1037 "commit", 1022 "commit",
1038 "commit_schemes_quota_goals", <<
1039 "update_schemes_stats", 1023 "update_schemes_stats",
1040 "update_schemes_tried_bytes", <<
1041 "update_schemes_tried_regions", 1024 "update_schemes_tried_regions",
1042 "clear_schemes_tried_regions", 1025 "clear_schemes_tried_regions",
1043 "update_schemes_effective_quotas", <<
1044 }; 1026 };
1045 1027
1046 /* 1028 /*
1047 * struct damon_sysfs_cmd_request - A request 1029 * struct damon_sysfs_cmd_request - A request to the DAMON callback.
1048 * @cmd: The command that needs to be 1030 * @cmd: The command that needs to be handled by the callback.
1049 * @kdamond: The kobject wrapper that asso 1031 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1050 * 1032 *
1051 * This structure represents a sysfs command 1033 * This structure represents a sysfs command request that need to access some
1052 * DAMON context-internal data. Because DAMO 1034 * DAMON context-internal data. Because DAMON context-internal data can be
1053 * safely accessed from DAMON callbacks witho 1035 * safely accessed from DAMON callbacks without additional synchronization, the
1054 * request will be handled by the DAMON callb 1036 * request will be handled by the DAMON callback. None-``NULL`` @kdamond means
1055 * the request is valid. 1037 * the request is valid.
1056 */ 1038 */
1057 struct damon_sysfs_cmd_request { 1039 struct damon_sysfs_cmd_request {
1058 enum damon_sysfs_cmd cmd; 1040 enum damon_sysfs_cmd cmd;
1059 struct damon_sysfs_kdamond *kdamond; 1041 struct damon_sysfs_kdamond *kdamond;
1060 }; 1042 };
1061 1043
1062 /* Current DAMON callback request. Protected 1044 /* Current DAMON callback request. Protected by damon_sysfs_lock. */
1063 static struct damon_sysfs_cmd_request damon_s 1045 static struct damon_sysfs_cmd_request damon_sysfs_cmd_request;
1064 1046
1065 static ssize_t state_show(struct kobject *kob 1047 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
1066 char *buf) 1048 char *buf)
1067 { 1049 {
1068 struct damon_sysfs_kdamond *kdamond = 1050 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1069 struct damon_sysfs_kd 1051 struct damon_sysfs_kdamond, kobj);
1070 struct damon_ctx *ctx = kdamond->damo 1052 struct damon_ctx *ctx = kdamond->damon_ctx;
1071 bool running; 1053 bool running;
1072 1054
1073 if (!ctx) 1055 if (!ctx)
1074 running = false; 1056 running = false;
1075 else 1057 else
1076 running = damon_sysfs_ctx_run 1058 running = damon_sysfs_ctx_running(ctx);
1077 1059
1078 return sysfs_emit(buf, "%s\n", runnin 1060 return sysfs_emit(buf, "%s\n", running ?
1079 damon_sysfs_cmd_strs[ 1061 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_ON] :
1080 damon_sysfs_cmd_strs[ 1062 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_OFF]);
1081 } 1063 }
1082 1064
1083 static int damon_sysfs_set_attrs(struct damon 1065 static int damon_sysfs_set_attrs(struct damon_ctx *ctx,
1084 struct damon_sysfs_attrs *sys 1066 struct damon_sysfs_attrs *sys_attrs)
1085 { 1067 {
1086 struct damon_sysfs_intervals *sys_int 1068 struct damon_sysfs_intervals *sys_intervals = sys_attrs->intervals;
1087 struct damon_sysfs_ul_range *sys_nr_r 1069 struct damon_sysfs_ul_range *sys_nr_regions =
1088 sys_attrs->nr_regions_range; 1070 sys_attrs->nr_regions_range;
1089 struct damon_attrs attrs = { 1071 struct damon_attrs attrs = {
1090 .sample_interval = sys_interv 1072 .sample_interval = sys_intervals->sample_us,
1091 .aggr_interval = sys_interval 1073 .aggr_interval = sys_intervals->aggr_us,
1092 .ops_update_interval = sys_in 1074 .ops_update_interval = sys_intervals->update_us,
1093 .min_nr_regions = sys_nr_regi 1075 .min_nr_regions = sys_nr_regions->min,
1094 .max_nr_regions = sys_nr_regi 1076 .max_nr_regions = sys_nr_regions->max,
1095 }; 1077 };
1096 return damon_set_attrs(ctx, &attrs); 1078 return damon_set_attrs(ctx, &attrs);
1097 } 1079 }
1098 1080
1099 static void damon_sysfs_destroy_targets(struc 1081 static void damon_sysfs_destroy_targets(struct damon_ctx *ctx)
1100 { 1082 {
1101 struct damon_target *t, *next; 1083 struct damon_target *t, *next;
1102 bool has_pid = damon_target_has_pid(c 1084 bool has_pid = damon_target_has_pid(ctx);
1103 1085
1104 damon_for_each_target_safe(t, next, c 1086 damon_for_each_target_safe(t, next, ctx) {
1105 if (has_pid) 1087 if (has_pid)
1106 put_pid(t->pid); 1088 put_pid(t->pid);
1107 damon_destroy_target(t); 1089 damon_destroy_target(t);
1108 } 1090 }
1109 } 1091 }
1110 1092
1111 static int damon_sysfs_set_regions(struct dam 1093 static int damon_sysfs_set_regions(struct damon_target *t,
1112 struct damon_sysfs_regions *s 1094 struct damon_sysfs_regions *sysfs_regions)
1113 { 1095 {
1114 struct damon_addr_range *ranges = kma 1096 struct damon_addr_range *ranges = kmalloc_array(sysfs_regions->nr,
1115 sizeof(*ranges), GFP_ 1097 sizeof(*ranges), GFP_KERNEL | __GFP_NOWARN);
1116 int i, err = -EINVAL; 1098 int i, err = -EINVAL;
1117 1099
1118 if (!ranges) 1100 if (!ranges)
1119 return -ENOMEM; 1101 return -ENOMEM;
1120 for (i = 0; i < sysfs_regions->nr; i+ 1102 for (i = 0; i < sysfs_regions->nr; i++) {
1121 struct damon_sysfs_region *sy 1103 struct damon_sysfs_region *sys_region =
1122 sysfs_regions->region 1104 sysfs_regions->regions_arr[i];
1123 1105
1124 if (sys_region->ar.start > sy 1106 if (sys_region->ar.start > sys_region->ar.end)
1125 goto out; 1107 goto out;
1126 1108
1127 ranges[i].start = sys_region- 1109 ranges[i].start = sys_region->ar.start;
1128 ranges[i].end = sys_region->a 1110 ranges[i].end = sys_region->ar.end;
1129 if (i == 0) 1111 if (i == 0)
1130 continue; 1112 continue;
1131 if (ranges[i - 1].end > range 1113 if (ranges[i - 1].end > ranges[i].start)
1132 goto out; 1114 goto out;
1133 } 1115 }
1134 err = damon_set_regions(t, ranges, sy 1116 err = damon_set_regions(t, ranges, sysfs_regions->nr);
1135 out: 1117 out:
1136 kfree(ranges); 1118 kfree(ranges);
1137 return err; 1119 return err;
1138 1120
1139 } 1121 }
1140 1122
1141 static int damon_sysfs_add_target(struct damo 1123 static int damon_sysfs_add_target(struct damon_sysfs_target *sys_target,
1142 struct damon_ctx *ctx) 1124 struct damon_ctx *ctx)
1143 { 1125 {
1144 struct damon_target *t = damon_new_ta 1126 struct damon_target *t = damon_new_target();
1145 int err = -EINVAL; 1127 int err = -EINVAL;
1146 1128
1147 if (!t) 1129 if (!t)
1148 return -ENOMEM; 1130 return -ENOMEM;
1149 damon_add_target(ctx, t); 1131 damon_add_target(ctx, t);
1150 if (damon_target_has_pid(ctx)) { 1132 if (damon_target_has_pid(ctx)) {
1151 t->pid = find_get_pid(sys_tar 1133 t->pid = find_get_pid(sys_target->pid);
1152 if (!t->pid) 1134 if (!t->pid)
1153 goto destroy_targets_ 1135 goto destroy_targets_out;
1154 } 1136 }
1155 err = damon_sysfs_set_regions(t, sys_ 1137 err = damon_sysfs_set_regions(t, sys_target->regions);
1156 if (err) 1138 if (err)
1157 goto destroy_targets_out; 1139 goto destroy_targets_out;
1158 return 0; 1140 return 0;
1159 1141
1160 destroy_targets_out: 1142 destroy_targets_out:
1161 damon_sysfs_destroy_targets(ctx); 1143 damon_sysfs_destroy_targets(ctx);
1162 return err; 1144 return err;
1163 } 1145 }
1164 1146
1165 static int damon_sysfs_add_targets(struct dam !! 1147 /*
>> 1148 * Search a target in a context that corresponds to the sysfs target input.
>> 1149 *
>> 1150 * Return: pointer to the target if found, NULL if not found, or negative
>> 1151 * error code if the search failed.
>> 1152 */
>> 1153 static struct damon_target *damon_sysfs_existing_target(
>> 1154 struct damon_sysfs_target *sys_target, struct damon_ctx *ctx)
>> 1155 {
>> 1156 struct pid *pid;
>> 1157 struct damon_target *t;
>> 1158
>> 1159 if (!damon_target_has_pid(ctx)) {
>> 1160 /* Up to only one target for paddr could exist */
>> 1161 damon_for_each_target(t, ctx)
>> 1162 return t;
>> 1163 return NULL;
>> 1164 }
>> 1165
>> 1166 /* ops.id should be DAMON_OPS_VADDR or DAMON_OPS_FVADDR */
>> 1167 pid = find_get_pid(sys_target->pid);
>> 1168 if (!pid)
>> 1169 return ERR_PTR(-EINVAL);
>> 1170 damon_for_each_target(t, ctx) {
>> 1171 if (t->pid == pid) {
>> 1172 put_pid(pid);
>> 1173 return t;
>> 1174 }
>> 1175 }
>> 1176 put_pid(pid);
>> 1177 return NULL;
>> 1178 }
>> 1179
>> 1180 static int damon_sysfs_set_targets(struct damon_ctx *ctx,
1166 struct damon_sysfs_targets *s 1181 struct damon_sysfs_targets *sysfs_targets)
1167 { 1182 {
1168 int i, err; 1183 int i, err;
1169 1184
1170 /* Multiple physical address space mo 1185 /* Multiple physical address space monitoring targets makes no sense */
1171 if (ctx->ops.id == DAMON_OPS_PADDR && 1186 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1)
1172 return -EINVAL; 1187 return -EINVAL;
1173 1188
1174 for (i = 0; i < sysfs_targets->nr; i+ 1189 for (i = 0; i < sysfs_targets->nr; i++) {
1175 struct damon_sysfs_target *st 1190 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i];
>> 1191 struct damon_target *t = damon_sysfs_existing_target(st, ctx);
1176 1192
1177 err = damon_sysfs_add_target( !! 1193 if (IS_ERR(t))
>> 1194 return PTR_ERR(t);
>> 1195 if (!t)
>> 1196 err = damon_sysfs_add_target(st, ctx);
>> 1197 else
>> 1198 err = damon_sysfs_set_regions(t, st->regions);
1178 if (err) 1199 if (err)
1179 return err; 1200 return err;
1180 } 1201 }
1181 return 0; 1202 return 0;
1182 } 1203 }
1183 1204
1184 static bool damon_sysfs_schemes_regions_updat <<
1185 <<
1186 static void damon_sysfs_before_terminate(stru 1205 static void damon_sysfs_before_terminate(struct damon_ctx *ctx)
1187 { 1206 {
1188 struct damon_target *t, *next; 1207 struct damon_target *t, *next;
1189 struct damon_sysfs_kdamond *kdamond; 1208 struct damon_sysfs_kdamond *kdamond;
1190 enum damon_sysfs_cmd cmd; <<
1191 1209
1192 /* damon_sysfs_schemes_update_regions 1210 /* damon_sysfs_schemes_update_regions_stop() might not yet called */
1193 kdamond = damon_sysfs_cmd_request.kda 1211 kdamond = damon_sysfs_cmd_request.kdamond;
1194 cmd = damon_sysfs_cmd_request.cmd; !! 1212 if (kdamond && damon_sysfs_cmd_request.cmd ==
1195 if (kdamond && ctx == kdamond->damon_ !! 1213 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS &&
1196 (cmd == DAMON_SYSFS_C !! 1214 ctx == kdamond->damon_ctx) {
1197 cmd == DAMON_SYSFS_C <<
1198 damon_sysfs_schemes_r <<
1199 damon_sysfs_schemes_update_re 1215 damon_sysfs_schemes_update_regions_stop(ctx);
1200 damon_sysfs_schemes_regions_u <<
1201 mutex_unlock(&damon_sysfs_loc 1216 mutex_unlock(&damon_sysfs_lock);
1202 } 1217 }
1203 1218
1204 if (!damon_target_has_pid(ctx)) 1219 if (!damon_target_has_pid(ctx))
1205 return; 1220 return;
1206 1221
1207 mutex_lock(&ctx->kdamond_lock); 1222 mutex_lock(&ctx->kdamond_lock);
1208 damon_for_each_target_safe(t, next, c 1223 damon_for_each_target_safe(t, next, ctx) {
1209 put_pid(t->pid); 1224 put_pid(t->pid);
1210 damon_destroy_target(t); 1225 damon_destroy_target(t);
1211 } 1226 }
1212 mutex_unlock(&ctx->kdamond_lock); 1227 mutex_unlock(&ctx->kdamond_lock);
1213 } 1228 }
1214 1229
1215 /* 1230 /*
1216 * damon_sysfs_upd_schemes_stats() - Update s 1231 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files.
1217 * @kdamond: The kobject wrapper that asso 1232 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1218 * 1233 *
1219 * This function reads the schemes stats of s 1234 * This function reads the schemes stats of specific kdamond and update the
1220 * related values for sysfs files. This func 1235 * related values for sysfs files. This function should be called from DAMON
1221 * callbacks while holding ``damon_syfs_lock` 1236 * callbacks while holding ``damon_syfs_lock``, to safely access the DAMON
1222 * contexts-internal data and DAMON sysfs var 1237 * contexts-internal data and DAMON sysfs variables.
1223 */ 1238 */
1224 static int damon_sysfs_upd_schemes_stats(stru 1239 static int damon_sysfs_upd_schemes_stats(struct damon_sysfs_kdamond *kdamond)
1225 { 1240 {
1226 struct damon_ctx *ctx = kdamond->damo 1241 struct damon_ctx *ctx = kdamond->damon_ctx;
1227 1242
1228 if (!ctx) 1243 if (!ctx)
1229 return -EINVAL; 1244 return -EINVAL;
1230 damon_sysfs_schemes_update_stats( 1245 damon_sysfs_schemes_update_stats(
1231 kdamond->contexts->co 1246 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1232 return 0; 1247 return 0;
1233 } 1248 }
1234 1249
1235 static int damon_sysfs_upd_schemes_regions_st 1250 static int damon_sysfs_upd_schemes_regions_start(
1236 struct damon_sysfs_kdamond *k !! 1251 struct damon_sysfs_kdamond *kdamond)
1237 { 1252 {
1238 struct damon_ctx *ctx = kdamond->damo 1253 struct damon_ctx *ctx = kdamond->damon_ctx;
1239 1254
1240 if (!ctx) 1255 if (!ctx)
1241 return -EINVAL; 1256 return -EINVAL;
1242 return damon_sysfs_schemes_update_reg 1257 return damon_sysfs_schemes_update_regions_start(
1243 kdamond->contexts->co !! 1258 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1244 total_bytes_only); <<
1245 } 1259 }
1246 1260
1247 static int damon_sysfs_upd_schemes_regions_st 1261 static int damon_sysfs_upd_schemes_regions_stop(
1248 struct damon_sysfs_kdamond *k 1262 struct damon_sysfs_kdamond *kdamond)
1249 { 1263 {
1250 struct damon_ctx *ctx = kdamond->damo 1264 struct damon_ctx *ctx = kdamond->damon_ctx;
1251 1265
1252 if (!ctx) 1266 if (!ctx)
1253 return -EINVAL; 1267 return -EINVAL;
1254 return damon_sysfs_schemes_update_reg 1268 return damon_sysfs_schemes_update_regions_stop(ctx);
1255 } 1269 }
1256 1270
1257 static int damon_sysfs_clear_schemes_regions( 1271 static int damon_sysfs_clear_schemes_regions(
1258 struct damon_sysfs_kdamond *k 1272 struct damon_sysfs_kdamond *kdamond)
1259 { 1273 {
1260 struct damon_ctx *ctx = kdamond->damo 1274 struct damon_ctx *ctx = kdamond->damon_ctx;
1261 1275
1262 if (!ctx) 1276 if (!ctx)
1263 return -EINVAL; 1277 return -EINVAL;
1264 return damon_sysfs_schemes_clear_regi 1278 return damon_sysfs_schemes_clear_regions(
1265 kdamond->contexts->co 1279 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1266 } 1280 }
1267 1281
1268 static inline bool damon_sysfs_kdamond_runnin 1282 static inline bool damon_sysfs_kdamond_running(
1269 struct damon_sysfs_kdamond *k 1283 struct damon_sysfs_kdamond *kdamond)
1270 { 1284 {
1271 return kdamond->damon_ctx && 1285 return kdamond->damon_ctx &&
1272 damon_sysfs_ctx_running(kdamo 1286 damon_sysfs_ctx_running(kdamond->damon_ctx);
1273 } 1287 }
1274 1288
1275 static int damon_sysfs_apply_inputs(struct da 1289 static int damon_sysfs_apply_inputs(struct damon_ctx *ctx,
1276 struct damon_sysfs_context *s 1290 struct damon_sysfs_context *sys_ctx)
1277 { 1291 {
1278 int err; 1292 int err;
1279 1293
1280 err = damon_select_ops(ctx, sys_ctx-> 1294 err = damon_select_ops(ctx, sys_ctx->ops_id);
1281 if (err) 1295 if (err)
1282 return err; 1296 return err;
1283 err = damon_sysfs_set_attrs(ctx, sys_ 1297 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs);
1284 if (err) 1298 if (err)
1285 return err; 1299 return err;
1286 err = damon_sysfs_add_targets(ctx, sy !! 1300 err = damon_sysfs_set_targets(ctx, sys_ctx->targets);
1287 if (err) 1301 if (err)
1288 return err; 1302 return err;
1289 return damon_sysfs_add_schemes(ctx, s !! 1303 return damon_sysfs_set_schemes(ctx, sys_ctx->schemes);
1290 } 1304 }
1291 1305
1292 static struct damon_ctx *damon_sysfs_build_ct <<
1293 struct damon_sysfs_context *s <<
1294 <<
1295 /* 1306 /*
1296 * damon_sysfs_commit_input() - Commit user i 1307 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond.
1297 * @kdamond: The kobject wrapper for the a 1308 * @kdamond: The kobject wrapper for the associated kdamond.
1298 * 1309 *
1299 * If the sysfs input is wrong, the kdamond w 1310 * If the sysfs input is wrong, the kdamond will be terminated.
1300 */ 1311 */
1301 static int damon_sysfs_commit_input(struct da 1312 static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond)
1302 { 1313 {
1303 struct damon_ctx *param_ctx; <<
1304 int err; <<
1305 <<
1306 if (!damon_sysfs_kdamond_running(kdam 1314 if (!damon_sysfs_kdamond_running(kdamond))
1307 return -EINVAL; 1315 return -EINVAL;
1308 /* TODO: Support multiple contexts pe 1316 /* TODO: Support multiple contexts per kdamond */
1309 if (kdamond->contexts->nr != 1) 1317 if (kdamond->contexts->nr != 1)
1310 return -EINVAL; 1318 return -EINVAL;
1311 1319
1312 param_ctx = damon_sysfs_build_ctx(kda !! 1320 return damon_sysfs_apply_inputs(kdamond->damon_ctx,
1313 if (IS_ERR(param_ctx)) !! 1321 kdamond->contexts->contexts_arr[0]);
1314 return PTR_ERR(param_ctx); <<
1315 err = damon_commit_ctx(kdamond->damon <<
1316 damon_sysfs_destroy_targets(param_ctx <<
1317 damon_destroy_ctx(param_ctx); <<
1318 return err; <<
1319 } <<
1320 <<
1321 static int damon_sysfs_commit_schemes_quota_g <<
1322 struct damon_sysfs_kdamond *s <<
1323 { <<
1324 struct damon_ctx *ctx; <<
1325 struct damon_sysfs_context *sysfs_ctx <<
1326 <<
1327 if (!damon_sysfs_kdamond_running(sysf <<
1328 return -EINVAL; <<
1329 /* TODO: Support multiple contexts pe <<
1330 if (sysfs_kdamond->contexts->nr != 1) <<
1331 return -EINVAL; <<
1332 <<
1333 ctx = sysfs_kdamond->damon_ctx; <<
1334 sysfs_ctx = sysfs_kdamond->contexts-> <<
1335 return damos_sysfs_set_quota_scores(s <<
1336 } <<
1337 <<
1338 /* <<
1339 * damon_sysfs_upd_schemes_effective_quotas() <<
1340 * sysfs files. <<
1341 * @kdamond: The kobject wrapper that asso <<
1342 * <<
1343 * This function reads the schemes' effective <<
1344 * update the related values for sysfs files. <<
1345 * from DAMON callbacks while holding ``damon <<
1346 * DAMON contexts-internal data and DAMON sys <<
1347 */ <<
1348 static int damon_sysfs_upd_schemes_effective_ <<
1349 struct damon_sysfs_kdamond *k <<
1350 { <<
1351 struct damon_ctx *ctx = kdamond->damo <<
1352 <<
1353 if (!ctx) <<
1354 return -EINVAL; <<
1355 damos_sysfs_update_effective_quotas( <<
1356 kdamond->contexts->co <<
1357 return 0; <<
1358 } 1322 }
1359 1323
1360 <<
1361 /* 1324 /*
1362 * damon_sysfs_cmd_request_callback() - DAMON 1325 * damon_sysfs_cmd_request_callback() - DAMON callback for handling requests.
1363 * @c: The DAMON context of the call !! 1326 * @c: The DAMON context of the callback.
1364 * @active: Whether @c is not deactivated <<
1365 * @after_aggr: Whether this is called from a <<
1366 * 1327 *
1367 * This function is periodically called back 1328 * This function is periodically called back from the kdamond thread for @c.
1368 * Then, it checks if there is a waiting DAMO 1329 * Then, it checks if there is a waiting DAMON sysfs request and handles it.
1369 */ 1330 */
1370 static int damon_sysfs_cmd_request_callback(s !! 1331 static int damon_sysfs_cmd_request_callback(struct damon_ctx *c)
1371 bool after_aggregation) <<
1372 { 1332 {
1373 struct damon_sysfs_kdamond *kdamond; 1333 struct damon_sysfs_kdamond *kdamond;
1374 bool total_bytes_only = false; !! 1334 static bool damon_sysfs_schemes_regions_updating;
1375 int err = 0; 1335 int err = 0;
1376 1336
1377 /* avoid deadlock due to concurrent s 1337 /* avoid deadlock due to concurrent state_store('off') */
1378 if (!damon_sysfs_schemes_regions_upda 1338 if (!damon_sysfs_schemes_regions_updating &&
1379 !mutex_trylock(&damon 1339 !mutex_trylock(&damon_sysfs_lock))
1380 return 0; 1340 return 0;
1381 kdamond = damon_sysfs_cmd_request.kda 1341 kdamond = damon_sysfs_cmd_request.kdamond;
1382 if (!kdamond || kdamond->damon_ctx != 1342 if (!kdamond || kdamond->damon_ctx != c)
1383 goto out; 1343 goto out;
1384 switch (damon_sysfs_cmd_request.cmd) 1344 switch (damon_sysfs_cmd_request.cmd) {
1385 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_S 1345 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS:
1386 err = damon_sysfs_upd_schemes 1346 err = damon_sysfs_upd_schemes_stats(kdamond);
1387 break; 1347 break;
1388 case DAMON_SYSFS_CMD_COMMIT: 1348 case DAMON_SYSFS_CMD_COMMIT:
1389 if (!after_aggregation) <<
1390 goto out; <<
1391 err = damon_sysfs_commit_inpu 1349 err = damon_sysfs_commit_input(kdamond);
1392 break; 1350 break;
1393 case DAMON_SYSFS_CMD_COMMIT_SCHEMES_Q <<
1394 err = damon_sysfs_commit_sche <<
1395 break; <<
1396 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_T <<
1397 total_bytes_only = true; <<
1398 fallthrough; <<
1399 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_T 1351 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS:
1400 if (!damon_sysfs_schemes_regi 1352 if (!damon_sysfs_schemes_regions_updating) {
1401 err = damon_sysfs_upd !! 1353 err = damon_sysfs_upd_schemes_regions_start(kdamond);
1402 total <<
1403 if (!err) { 1354 if (!err) {
1404 damon_sysfs_s 1355 damon_sysfs_schemes_regions_updating = true;
1405 goto keep_loc 1356 goto keep_lock_out;
1406 } 1357 }
1407 } else { 1358 } else {
1408 damos_sysfs_mark_fini <<
1409 /* <<
1410 * Continue regions u <<
1411 * active and the upd <<
1412 * finished. <<
1413 */ <<
1414 if (active && !damos_ <<
1415 goto keep_loc <<
1416 err = damon_sysfs_upd 1359 err = damon_sysfs_upd_schemes_regions_stop(kdamond);
1417 damon_sysfs_schemes_r 1360 damon_sysfs_schemes_regions_updating = false;
1418 } 1361 }
1419 break; 1362 break;
1420 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TR 1363 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS:
1421 err = damon_sysfs_clear_schem 1364 err = damon_sysfs_clear_schemes_regions(kdamond);
1422 break; 1365 break;
1423 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_E <<
1424 err = damon_sysfs_upd_schemes <<
1425 break; <<
1426 default: 1366 default:
1427 break; 1367 break;
1428 } 1368 }
1429 /* Mark the request as invalid now. * 1369 /* Mark the request as invalid now. */
1430 damon_sysfs_cmd_request.kdamond = NUL 1370 damon_sysfs_cmd_request.kdamond = NULL;
1431 out: 1371 out:
1432 if (!damon_sysfs_schemes_regions_upda 1372 if (!damon_sysfs_schemes_regions_updating)
1433 mutex_unlock(&damon_sysfs_loc 1373 mutex_unlock(&damon_sysfs_lock);
1434 keep_lock_out: 1374 keep_lock_out:
1435 return err; 1375 return err;
1436 } 1376 }
1437 1377
1438 static int damon_sysfs_after_wmarks_check(str <<
1439 { <<
1440 /* <<
1441 * after_wmarks_check() is called bac <<
1442 * by watermarks. <<
1443 */ <<
1444 return damon_sysfs_cmd_request_callba <<
1445 } <<
1446 <<
1447 static int damon_sysfs_after_sampling(struct <<
1448 { <<
1449 /* <<
1450 * after_sampling() is called back on <<
1451 * deactivated by watermarks. <<
1452 */ <<
1453 return damon_sysfs_cmd_request_callba <<
1454 } <<
1455 <<
1456 static int damon_sysfs_after_aggregation(stru <<
1457 { <<
1458 /* <<
1459 * after_aggregation() is called back <<
1460 * deactivated by watermarks. <<
1461 */ <<
1462 return damon_sysfs_cmd_request_callba <<
1463 } <<
1464 <<
1465 static struct damon_ctx *damon_sysfs_build_ct 1378 static struct damon_ctx *damon_sysfs_build_ctx(
1466 struct damon_sysfs_context *s 1379 struct damon_sysfs_context *sys_ctx)
1467 { 1380 {
1468 struct damon_ctx *ctx = damon_new_ctx 1381 struct damon_ctx *ctx = damon_new_ctx();
1469 int err; 1382 int err;
1470 1383
1471 if (!ctx) 1384 if (!ctx)
1472 return ERR_PTR(-ENOMEM); 1385 return ERR_PTR(-ENOMEM);
1473 1386
1474 err = damon_sysfs_apply_inputs(ctx, s 1387 err = damon_sysfs_apply_inputs(ctx, sys_ctx);
1475 if (err) { 1388 if (err) {
1476 damon_destroy_ctx(ctx); 1389 damon_destroy_ctx(ctx);
1477 return ERR_PTR(err); 1390 return ERR_PTR(err);
1478 } 1391 }
1479 1392
1480 ctx->callback.after_wmarks_check = da !! 1393 ctx->callback.after_wmarks_check = damon_sysfs_cmd_request_callback;
1481 ctx->callback.after_sampling = damon_ !! 1394 ctx->callback.after_aggregation = damon_sysfs_cmd_request_callback;
1482 ctx->callback.after_aggregation = dam <<
1483 ctx->callback.before_terminate = damo 1395 ctx->callback.before_terminate = damon_sysfs_before_terminate;
1484 return ctx; 1396 return ctx;
1485 } 1397 }
1486 1398
1487 static int damon_sysfs_turn_damon_on(struct d 1399 static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond)
1488 { 1400 {
1489 struct damon_ctx *ctx; 1401 struct damon_ctx *ctx;
1490 int err; 1402 int err;
1491 1403
1492 if (damon_sysfs_kdamond_running(kdamo 1404 if (damon_sysfs_kdamond_running(kdamond))
1493 return -EBUSY; 1405 return -EBUSY;
1494 if (damon_sysfs_cmd_request.kdamond = 1406 if (damon_sysfs_cmd_request.kdamond == kdamond)
1495 return -EBUSY; 1407 return -EBUSY;
1496 /* TODO: support multiple contexts pe 1408 /* TODO: support multiple contexts per kdamond */
1497 if (kdamond->contexts->nr != 1) 1409 if (kdamond->contexts->nr != 1)
1498 return -EINVAL; 1410 return -EINVAL;
1499 1411
1500 if (kdamond->damon_ctx) 1412 if (kdamond->damon_ctx)
1501 damon_destroy_ctx(kdamond->da 1413 damon_destroy_ctx(kdamond->damon_ctx);
1502 kdamond->damon_ctx = NULL; 1414 kdamond->damon_ctx = NULL;
1503 1415
1504 ctx = damon_sysfs_build_ctx(kdamond-> 1416 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);
1505 if (IS_ERR(ctx)) 1417 if (IS_ERR(ctx))
1506 return PTR_ERR(ctx); 1418 return PTR_ERR(ctx);
1507 err = damon_start(&ctx, 1, false); 1419 err = damon_start(&ctx, 1, false);
1508 if (err) { 1420 if (err) {
1509 damon_destroy_ctx(ctx); 1421 damon_destroy_ctx(ctx);
1510 return err; 1422 return err;
1511 } 1423 }
1512 kdamond->damon_ctx = ctx; 1424 kdamond->damon_ctx = ctx;
1513 return err; 1425 return err;
1514 } 1426 }
1515 1427
1516 static int damon_sysfs_turn_damon_off(struct 1428 static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond)
1517 { 1429 {
1518 if (!kdamond->damon_ctx) 1430 if (!kdamond->damon_ctx)
1519 return -EINVAL; 1431 return -EINVAL;
1520 return damon_stop(&kdamond->damon_ctx 1432 return damon_stop(&kdamond->damon_ctx, 1);
1521 /* 1433 /*
1522 * To allow users show final monitori 1434 * To allow users show final monitoring results of already turned-off
1523 * DAMON, we free kdamond->damon_ctx 1435 * DAMON, we free kdamond->damon_ctx in next
1524 * damon_sysfs_turn_damon_on(), or kd 1436 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store()
1525 */ 1437 */
1526 } 1438 }
1527 1439
1528 /* 1440 /*
1529 * damon_sysfs_handle_cmd() - Handle a comman 1441 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond.
1530 * @cmd: The command to handle. 1442 * @cmd: The command to handle.
1531 * @kdamond: The kobject wrapper for the a 1443 * @kdamond: The kobject wrapper for the associated kdamond.
1532 * 1444 *
1533 * This function handles a DAMON sysfs comman 1445 * This function handles a DAMON sysfs command for a kdamond. For commands
1534 * that need to access running DAMON context- 1446 * that need to access running DAMON context-internal data, it requests
1535 * handling of the command to the DAMON callb 1447 * handling of the command to the DAMON callback
1536 * (@damon_sysfs_cmd_request_callback()) and 1448 * (@damon_sysfs_cmd_request_callback()) and wait until it is properly handled,
1537 * or the context is completed. 1449 * or the context is completed.
1538 * 1450 *
1539 * Return: 0 on success, negative error code 1451 * Return: 0 on success, negative error code otherwise.
1540 */ 1452 */
1541 static int damon_sysfs_handle_cmd(enum damon_ 1453 static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd,
1542 struct damon_sysfs_kdamond *k 1454 struct damon_sysfs_kdamond *kdamond)
1543 { 1455 {
1544 bool need_wait = true; 1456 bool need_wait = true;
1545 1457
1546 /* Handle commands that doesn't acces 1458 /* Handle commands that doesn't access DAMON context-internal data */
1547 switch (cmd) { 1459 switch (cmd) {
1548 case DAMON_SYSFS_CMD_ON: 1460 case DAMON_SYSFS_CMD_ON:
1549 return damon_sysfs_turn_damon 1461 return damon_sysfs_turn_damon_on(kdamond);
1550 case DAMON_SYSFS_CMD_OFF: 1462 case DAMON_SYSFS_CMD_OFF:
1551 return damon_sysfs_turn_damon 1463 return damon_sysfs_turn_damon_off(kdamond);
1552 default: 1464 default:
1553 break; 1465 break;
1554 } 1466 }
1555 1467
1556 /* Pass the command to DAMON callback 1468 /* Pass the command to DAMON callback for safe DAMON context access */
1557 if (damon_sysfs_cmd_request.kdamond) 1469 if (damon_sysfs_cmd_request.kdamond)
1558 return -EBUSY; 1470 return -EBUSY;
1559 if (!damon_sysfs_kdamond_running(kdam 1471 if (!damon_sysfs_kdamond_running(kdamond))
1560 return -EINVAL; 1472 return -EINVAL;
1561 damon_sysfs_cmd_request.cmd = cmd; 1473 damon_sysfs_cmd_request.cmd = cmd;
1562 damon_sysfs_cmd_request.kdamond = kda 1474 damon_sysfs_cmd_request.kdamond = kdamond;
1563 1475
1564 /* 1476 /*
1565 * wait until damon_sysfs_cmd_request 1477 * wait until damon_sysfs_cmd_request_callback() handles the request
1566 * from kdamond context 1478 * from kdamond context
1567 */ 1479 */
1568 mutex_unlock(&damon_sysfs_lock); 1480 mutex_unlock(&damon_sysfs_lock);
1569 while (need_wait) { 1481 while (need_wait) {
1570 schedule_timeout_idle(msecs_t 1482 schedule_timeout_idle(msecs_to_jiffies(100));
1571 if (!mutex_trylock(&damon_sys 1483 if (!mutex_trylock(&damon_sysfs_lock))
1572 continue; 1484 continue;
1573 if (!damon_sysfs_cmd_request. 1485 if (!damon_sysfs_cmd_request.kdamond) {
1574 /* damon_sysfs_cmd_re 1486 /* damon_sysfs_cmd_request_callback() handled */
1575 need_wait = false; 1487 need_wait = false;
1576 } else if (!damon_sysfs_kdamo 1488 } else if (!damon_sysfs_kdamond_running(kdamond)) {
1577 /* kdamond has alread 1489 /* kdamond has already finished */
1578 need_wait = false; 1490 need_wait = false;
1579 damon_sysfs_cmd_reque 1491 damon_sysfs_cmd_request.kdamond = NULL;
1580 } 1492 }
1581 mutex_unlock(&damon_sysfs_loc 1493 mutex_unlock(&damon_sysfs_lock);
1582 } 1494 }
1583 mutex_lock(&damon_sysfs_lock); 1495 mutex_lock(&damon_sysfs_lock);
1584 return 0; 1496 return 0;
1585 } 1497 }
1586 1498
1587 static ssize_t state_store(struct kobject *ko 1499 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
1588 const char *buf, size_t count 1500 const char *buf, size_t count)
1589 { 1501 {
1590 struct damon_sysfs_kdamond *kdamond = 1502 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1591 struct damon_sysfs_kd 1503 struct damon_sysfs_kdamond, kobj);
1592 enum damon_sysfs_cmd cmd; 1504 enum damon_sysfs_cmd cmd;
1593 ssize_t ret = -EINVAL; 1505 ssize_t ret = -EINVAL;
1594 1506
1595 if (!mutex_trylock(&damon_sysfs_lock) 1507 if (!mutex_trylock(&damon_sysfs_lock))
1596 return -EBUSY; 1508 return -EBUSY;
1597 for (cmd = 0; cmd < NR_DAMON_SYSFS_CM 1509 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) {
1598 if (sysfs_streq(buf, damon_sy 1510 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) {
1599 ret = damon_sysfs_han 1511 ret = damon_sysfs_handle_cmd(cmd, kdamond);
1600 break; 1512 break;
1601 } 1513 }
1602 } 1514 }
1603 mutex_unlock(&damon_sysfs_lock); 1515 mutex_unlock(&damon_sysfs_lock);
1604 if (!ret) 1516 if (!ret)
1605 ret = count; 1517 ret = count;
1606 return ret; 1518 return ret;
1607 } 1519 }
1608 1520
1609 static ssize_t pid_show(struct kobject *kobj, 1521 static ssize_t pid_show(struct kobject *kobj,
1610 struct kobj_attribute *attr, 1522 struct kobj_attribute *attr, char *buf)
1611 { 1523 {
1612 struct damon_sysfs_kdamond *kdamond = 1524 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1613 struct damon_sysfs_kd 1525 struct damon_sysfs_kdamond, kobj);
1614 struct damon_ctx *ctx; 1526 struct damon_ctx *ctx;
1615 int pid = -1; 1527 int pid = -1;
1616 1528
1617 if (!mutex_trylock(&damon_sysfs_lock) 1529 if (!mutex_trylock(&damon_sysfs_lock))
1618 return -EBUSY; 1530 return -EBUSY;
1619 ctx = kdamond->damon_ctx; 1531 ctx = kdamond->damon_ctx;
1620 if (!ctx) 1532 if (!ctx)
1621 goto out; 1533 goto out;
1622 1534
1623 mutex_lock(&ctx->kdamond_lock); 1535 mutex_lock(&ctx->kdamond_lock);
1624 if (ctx->kdamond) 1536 if (ctx->kdamond)
1625 pid = ctx->kdamond->pid; 1537 pid = ctx->kdamond->pid;
1626 mutex_unlock(&ctx->kdamond_lock); 1538 mutex_unlock(&ctx->kdamond_lock);
1627 out: 1539 out:
1628 mutex_unlock(&damon_sysfs_lock); 1540 mutex_unlock(&damon_sysfs_lock);
1629 return sysfs_emit(buf, "%d\n", pid); 1541 return sysfs_emit(buf, "%d\n", pid);
1630 } 1542 }
1631 1543
1632 static void damon_sysfs_kdamond_release(struc 1544 static void damon_sysfs_kdamond_release(struct kobject *kobj)
1633 { 1545 {
1634 struct damon_sysfs_kdamond *kdamond = 1546 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1635 struct damon_sysfs_kd 1547 struct damon_sysfs_kdamond, kobj);
1636 1548
1637 if (kdamond->damon_ctx) 1549 if (kdamond->damon_ctx)
1638 damon_destroy_ctx(kdamond->da 1550 damon_destroy_ctx(kdamond->damon_ctx);
1639 kfree(kdamond); 1551 kfree(kdamond);
1640 } 1552 }
1641 1553
1642 static struct kobj_attribute damon_sysfs_kdam 1554 static struct kobj_attribute damon_sysfs_kdamond_state_attr =
1643 __ATTR_RW_MODE(state, 0600); 1555 __ATTR_RW_MODE(state, 0600);
1644 1556
1645 static struct kobj_attribute damon_sysfs_kdam 1557 static struct kobj_attribute damon_sysfs_kdamond_pid_attr =
1646 __ATTR_RO_MODE(pid, 0400); 1558 __ATTR_RO_MODE(pid, 0400);
1647 1559
1648 static struct attribute *damon_sysfs_kdamond_ 1560 static struct attribute *damon_sysfs_kdamond_attrs[] = {
1649 &damon_sysfs_kdamond_state_attr.attr, 1561 &damon_sysfs_kdamond_state_attr.attr,
1650 &damon_sysfs_kdamond_pid_attr.attr, 1562 &damon_sysfs_kdamond_pid_attr.attr,
1651 NULL, 1563 NULL,
1652 }; 1564 };
1653 ATTRIBUTE_GROUPS(damon_sysfs_kdamond); 1565 ATTRIBUTE_GROUPS(damon_sysfs_kdamond);
1654 1566
1655 static const struct kobj_type damon_sysfs_kda 1567 static const struct kobj_type damon_sysfs_kdamond_ktype = {
1656 .release = damon_sysfs_kdamond_releas 1568 .release = damon_sysfs_kdamond_release,
1657 .sysfs_ops = &kobj_sysfs_ops, 1569 .sysfs_ops = &kobj_sysfs_ops,
1658 .default_groups = damon_sysfs_kdamond 1570 .default_groups = damon_sysfs_kdamond_groups,
1659 }; 1571 };
1660 1572
1661 /* 1573 /*
1662 * kdamonds directory 1574 * kdamonds directory
1663 */ 1575 */
1664 1576
1665 struct damon_sysfs_kdamonds { 1577 struct damon_sysfs_kdamonds {
1666 struct kobject kobj; 1578 struct kobject kobj;
1667 struct damon_sysfs_kdamond **kdamonds 1579 struct damon_sysfs_kdamond **kdamonds_arr;
1668 int nr; 1580 int nr;
1669 }; 1581 };
1670 1582
1671 static struct damon_sysfs_kdamonds *damon_sys 1583 static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void)
1672 { 1584 {
1673 return kzalloc(sizeof(struct damon_sy 1585 return kzalloc(sizeof(struct damon_sysfs_kdamonds), GFP_KERNEL);
1674 } 1586 }
1675 1587
1676 static void damon_sysfs_kdamonds_rm_dirs(stru 1588 static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds)
1677 { 1589 {
1678 struct damon_sysfs_kdamond **kdamonds 1590 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr;
1679 int i; 1591 int i;
1680 1592
1681 for (i = 0; i < kdamonds->nr; i++) { 1593 for (i = 0; i < kdamonds->nr; i++) {
1682 damon_sysfs_kdamond_rm_dirs(k 1594 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]);
1683 kobject_put(&kdamonds_arr[i]- 1595 kobject_put(&kdamonds_arr[i]->kobj);
1684 } 1596 }
1685 kdamonds->nr = 0; 1597 kdamonds->nr = 0;
1686 kfree(kdamonds_arr); 1598 kfree(kdamonds_arr);
1687 kdamonds->kdamonds_arr = NULL; 1599 kdamonds->kdamonds_arr = NULL;
1688 } 1600 }
1689 1601
1690 static bool damon_sysfs_kdamonds_busy(struct 1602 static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds,
1691 int nr_kdamonds) 1603 int nr_kdamonds)
1692 { 1604 {
1693 int i; 1605 int i;
1694 1606
1695 for (i = 0; i < nr_kdamonds; i++) { 1607 for (i = 0; i < nr_kdamonds; i++) {
1696 if (damon_sysfs_kdamond_runni 1608 if (damon_sysfs_kdamond_running(kdamonds[i]) ||
1697 damon_sysfs_cmd_request.k 1609 damon_sysfs_cmd_request.kdamond == kdamonds[i])
1698 return true; 1610 return true;
1699 } 1611 }
1700 1612
1701 return false; 1613 return false;
1702 } 1614 }
1703 1615
1704 static int damon_sysfs_kdamonds_add_dirs(stru 1616 static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds,
1705 int nr_kdamonds) 1617 int nr_kdamonds)
1706 { 1618 {
1707 struct damon_sysfs_kdamond **kdamonds 1619 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond;
1708 int err, i; 1620 int err, i;
1709 1621
1710 if (damon_sysfs_kdamonds_busy(kdamond 1622 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr))
1711 return -EBUSY; 1623 return -EBUSY;
1712 1624
1713 damon_sysfs_kdamonds_rm_dirs(kdamonds 1625 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1714 if (!nr_kdamonds) 1626 if (!nr_kdamonds)
1715 return 0; 1627 return 0;
1716 1628
1717 kdamonds_arr = kmalloc_array(nr_kdamo 1629 kdamonds_arr = kmalloc_array(nr_kdamonds, sizeof(*kdamonds_arr),
1718 GFP_KERNEL | __GFP_NO 1630 GFP_KERNEL | __GFP_NOWARN);
1719 if (!kdamonds_arr) 1631 if (!kdamonds_arr)
1720 return -ENOMEM; 1632 return -ENOMEM;
1721 kdamonds->kdamonds_arr = kdamonds_arr 1633 kdamonds->kdamonds_arr = kdamonds_arr;
1722 1634
1723 for (i = 0; i < nr_kdamonds; i++) { 1635 for (i = 0; i < nr_kdamonds; i++) {
1724 kdamond = damon_sysfs_kdamond 1636 kdamond = damon_sysfs_kdamond_alloc();
1725 if (!kdamond) { 1637 if (!kdamond) {
1726 damon_sysfs_kdamonds_ 1638 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1727 return -ENOMEM; 1639 return -ENOMEM;
1728 } 1640 }
1729 1641
1730 err = kobject_init_and_add(&k 1642 err = kobject_init_and_add(&kdamond->kobj,
1731 &damon_sysfs_ 1643 &damon_sysfs_kdamond_ktype, &kdamonds->kobj,
1732 "%d", i); 1644 "%d", i);
1733 if (err) 1645 if (err)
1734 goto out; 1646 goto out;
1735 1647
1736 err = damon_sysfs_kdamond_add 1648 err = damon_sysfs_kdamond_add_dirs(kdamond);
1737 if (err) 1649 if (err)
1738 goto out; 1650 goto out;
1739 1651
1740 kdamonds_arr[i] = kdamond; 1652 kdamonds_arr[i] = kdamond;
1741 kdamonds->nr++; 1653 kdamonds->nr++;
1742 } 1654 }
1743 return 0; 1655 return 0;
1744 1656
1745 out: 1657 out:
1746 damon_sysfs_kdamonds_rm_dirs(kdamonds 1658 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1747 kobject_put(&kdamond->kobj); 1659 kobject_put(&kdamond->kobj);
1748 return err; 1660 return err;
1749 } 1661 }
1750 1662
1751 static ssize_t nr_kdamonds_show(struct kobjec 1663 static ssize_t nr_kdamonds_show(struct kobject *kobj,
1752 struct kobj_attribute *attr, 1664 struct kobj_attribute *attr, char *buf)
1753 { 1665 {
1754 struct damon_sysfs_kdamonds *kdamonds 1666 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj,
1755 struct damon_sysfs_kd 1667 struct damon_sysfs_kdamonds, kobj);
1756 1668
1757 return sysfs_emit(buf, "%d\n", kdamon 1669 return sysfs_emit(buf, "%d\n", kdamonds->nr);
1758 } 1670 }
1759 1671
1760 static ssize_t nr_kdamonds_store(struct kobje 1672 static ssize_t nr_kdamonds_store(struct kobject *kobj,
1761 struct kobj_attribute *attr, 1673 struct kobj_attribute *attr, const char *buf, size_t count)
1762 { 1674 {
1763 struct damon_sysfs_kdamonds *kdamonds 1675 struct damon_sysfs_kdamonds *kdamonds;
1764 int nr, err; 1676 int nr, err;
1765 1677
1766 err = kstrtoint(buf, 0, &nr); 1678 err = kstrtoint(buf, 0, &nr);
1767 if (err) 1679 if (err)
1768 return err; 1680 return err;
1769 if (nr < 0) 1681 if (nr < 0)
1770 return -EINVAL; 1682 return -EINVAL;
1771 1683
1772 kdamonds = container_of(kobj, struct 1684 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj);
1773 1685
1774 if (!mutex_trylock(&damon_sysfs_lock) 1686 if (!mutex_trylock(&damon_sysfs_lock))
1775 return -EBUSY; 1687 return -EBUSY;
1776 err = damon_sysfs_kdamonds_add_dirs(k 1688 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr);
1777 mutex_unlock(&damon_sysfs_lock); 1689 mutex_unlock(&damon_sysfs_lock);
1778 if (err) 1690 if (err)
1779 return err; 1691 return err;
1780 1692
1781 return count; 1693 return count;
1782 } 1694 }
1783 1695
1784 static void damon_sysfs_kdamonds_release(stru 1696 static void damon_sysfs_kdamonds_release(struct kobject *kobj)
1785 { 1697 {
1786 kfree(container_of(kobj, struct damon 1698 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj));
1787 } 1699 }
1788 1700
1789 static struct kobj_attribute damon_sysfs_kdam 1701 static struct kobj_attribute damon_sysfs_kdamonds_nr_attr =
1790 __ATTR_RW_MODE(nr_kdamonds, 0 1702 __ATTR_RW_MODE(nr_kdamonds, 0600);
1791 1703
1792 static struct attribute *damon_sysfs_kdamonds 1704 static struct attribute *damon_sysfs_kdamonds_attrs[] = {
1793 &damon_sysfs_kdamonds_nr_attr.attr, 1705 &damon_sysfs_kdamonds_nr_attr.attr,
1794 NULL, 1706 NULL,
1795 }; 1707 };
1796 ATTRIBUTE_GROUPS(damon_sysfs_kdamonds); 1708 ATTRIBUTE_GROUPS(damon_sysfs_kdamonds);
1797 1709
1798 static const struct kobj_type damon_sysfs_kda 1710 static const struct kobj_type damon_sysfs_kdamonds_ktype = {
1799 .release = damon_sysfs_kdamonds_relea 1711 .release = damon_sysfs_kdamonds_release,
1800 .sysfs_ops = &kobj_sysfs_ops, 1712 .sysfs_ops = &kobj_sysfs_ops,
1801 .default_groups = damon_sysfs_kdamond 1713 .default_groups = damon_sysfs_kdamonds_groups,
1802 }; 1714 };
1803 1715
1804 /* 1716 /*
1805 * damon user interface directory 1717 * damon user interface directory
1806 */ 1718 */
1807 1719
1808 struct damon_sysfs_ui_dir { 1720 struct damon_sysfs_ui_dir {
1809 struct kobject kobj; 1721 struct kobject kobj;
1810 struct damon_sysfs_kdamonds *kdamonds 1722 struct damon_sysfs_kdamonds *kdamonds;
1811 }; 1723 };
1812 1724
1813 static struct damon_sysfs_ui_dir *damon_sysfs 1725 static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void)
1814 { 1726 {
1815 return kzalloc(sizeof(struct damon_sy 1727 return kzalloc(sizeof(struct damon_sysfs_ui_dir), GFP_KERNEL);
1816 } 1728 }
1817 1729
1818 static int damon_sysfs_ui_dir_add_dirs(struct 1730 static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir)
1819 { 1731 {
1820 struct damon_sysfs_kdamonds *kdamonds 1732 struct damon_sysfs_kdamonds *kdamonds;
1821 int err; 1733 int err;
1822 1734
1823 kdamonds = damon_sysfs_kdamonds_alloc 1735 kdamonds = damon_sysfs_kdamonds_alloc();
1824 if (!kdamonds) 1736 if (!kdamonds)
1825 return -ENOMEM; 1737 return -ENOMEM;
1826 1738
1827 err = kobject_init_and_add(&kdamonds- 1739 err = kobject_init_and_add(&kdamonds->kobj,
1828 &damon_sysfs_kdamonds 1740 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj,
1829 "kdamonds"); 1741 "kdamonds");
1830 if (err) { 1742 if (err) {
1831 kobject_put(&kdamonds->kobj); 1743 kobject_put(&kdamonds->kobj);
1832 return err; 1744 return err;
1833 } 1745 }
1834 ui_dir->kdamonds = kdamonds; 1746 ui_dir->kdamonds = kdamonds;
1835 return err; 1747 return err;
1836 } 1748 }
1837 1749
1838 static void damon_sysfs_ui_dir_release(struct 1750 static void damon_sysfs_ui_dir_release(struct kobject *kobj)
1839 { 1751 {
1840 kfree(container_of(kobj, struct damon 1752 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj));
1841 } 1753 }
1842 1754
1843 static struct attribute *damon_sysfs_ui_dir_a 1755 static struct attribute *damon_sysfs_ui_dir_attrs[] = {
1844 NULL, 1756 NULL,
1845 }; 1757 };
1846 ATTRIBUTE_GROUPS(damon_sysfs_ui_dir); 1758 ATTRIBUTE_GROUPS(damon_sysfs_ui_dir);
1847 1759
1848 static const struct kobj_type damon_sysfs_ui_ 1760 static const struct kobj_type damon_sysfs_ui_dir_ktype = {
1849 .release = damon_sysfs_ui_dir_release 1761 .release = damon_sysfs_ui_dir_release,
1850 .sysfs_ops = &kobj_sysfs_ops, 1762 .sysfs_ops = &kobj_sysfs_ops,
1851 .default_groups = damon_sysfs_ui_dir_ 1763 .default_groups = damon_sysfs_ui_dir_groups,
1852 }; 1764 };
1853 1765
1854 static int __init damon_sysfs_init(void) 1766 static int __init damon_sysfs_init(void)
1855 { 1767 {
1856 struct kobject *damon_sysfs_root; 1768 struct kobject *damon_sysfs_root;
1857 struct damon_sysfs_ui_dir *admin; 1769 struct damon_sysfs_ui_dir *admin;
1858 int err; 1770 int err;
1859 1771
1860 damon_sysfs_root = kobject_create_and 1772 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj);
1861 if (!damon_sysfs_root) 1773 if (!damon_sysfs_root)
1862 return -ENOMEM; 1774 return -ENOMEM;
1863 1775
1864 admin = damon_sysfs_ui_dir_alloc(); 1776 admin = damon_sysfs_ui_dir_alloc();
1865 if (!admin) { 1777 if (!admin) {
1866 kobject_put(damon_sysfs_root) 1778 kobject_put(damon_sysfs_root);
1867 return -ENOMEM; 1779 return -ENOMEM;
1868 } 1780 }
1869 err = kobject_init_and_add(&admin->ko 1781 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype,
1870 damon_sysfs_root, "ad 1782 damon_sysfs_root, "admin");
1871 if (err) 1783 if (err)
1872 goto out; 1784 goto out;
1873 err = damon_sysfs_ui_dir_add_dirs(adm 1785 err = damon_sysfs_ui_dir_add_dirs(admin);
1874 if (err) 1786 if (err)
1875 goto out; 1787 goto out;
1876 return 0; 1788 return 0;
1877 1789
1878 out: 1790 out:
1879 kobject_put(&admin->kobj); 1791 kobject_put(&admin->kobj);
1880 kobject_put(damon_sysfs_root); 1792 kobject_put(damon_sysfs_root);
1881 return err; 1793 return err;
1882 } 1794 }
1883 subsys_initcall(damon_sysfs_init); 1795 subsys_initcall(damon_sysfs_init);
1884 <<
1885 #include "tests/sysfs-kunit.h" <<
1886 1796
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.