1 /* 2 * fs/sysfs/file.c - sysfs regular (text) file implementation 3 * 4 * Copyright (c) 2001-3 Patrick Mochel 5 * Copyright (c) 2007 SUSE Linux Products GmbH 6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de> 7 * 8 * This file is released under the GPLv2. 9 * 10 * Please see Documentation/filesystems/sysfs.txt for more information. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/kobject.h> 15 #include <linux/kallsyms.h> 16 #include <linux/slab.h> 17 #include <linux/list.h> 18 #include <linux/mutex.h> 19 #include <linux/seq_file.h> 20 21 #include "sysfs.h" 22 #include "../kernfs/kernfs-internal.h" 23 24 /* 25 * Determine ktype->sysfs_ops for the given kernfs_node. This function 26 * must be called while holding an active reference. 27 */ 28 static const struct sysfs_ops *sysfs_file_ops(struct kernfs_node *kn) 29 { 30 struct kobject *kobj = kn->parent->priv; 31 32 if (kn->flags & KERNFS_LOCKDEP) 33 lockdep_assert_held(kn); 34 return kobj->ktype ? kobj->ktype->sysfs_ops : NULL; 35 } 36 37 /* 38 * Reads on sysfs are handled through seq_file, which takes care of hairy 39 * details like buffering and seeking. The following function pipes 40 * sysfs_ops->show() result through seq_file. 41 */ 42 static int sysfs_kf_seq_show(struct seq_file *sf, void *v) 43 { 44 struct kernfs_open_file *of = sf->private; 45 struct kobject *kobj = of->kn->parent->priv; 46 const struct sysfs_ops *ops = sysfs_file_ops(of->kn); 47 ssize_t count; 48 char *buf; 49 50 /* acquire buffer and ensure that it's >= PAGE_SIZE and clear */ 51 count = seq_get_buf(sf, &buf); 52 if (count < PAGE_SIZE) { 53 seq_commit(sf, -1); 54 return 0; 55 } 56 memset(buf, 0, PAGE_SIZE); 57 58 /* 59 * Invoke show(). Control may reach here via seq file lseek even 60 * if @ops->show() isn't implemented. 61 */ 62 if (ops->show) { 63 count = ops->show(kobj, of->kn->priv, buf); 64 if (count < 0) 65 return count; 66 } 67 68 /* 69 * The code works fine with PAGE_SIZE return but it's likely to 70 * indicate truncated result or overflow in normal use cases. 71 */ 72 if (count >= (ssize_t)PAGE_SIZE) { 73 print_symbol("fill_read_buffer: %s returned bad count\n", 74 (unsigned long)ops->show); 75 /* Try to struggle along */ 76 count = PAGE_SIZE - 1; 77 } 78 seq_commit(sf, count); 79 return 0; 80 } 81 82 static ssize_t sysfs_kf_bin_read(struct kernfs_open_file *of, char *buf, 83 size_t count, loff_t pos) 84 { 85 struct bin_attribute *battr = of->kn->priv; 86 struct kobject *kobj = of->kn->parent->priv; 87 loff_t size = file_inode(of->file)->i_size; 88 89 if (!count) 90 return 0; 91 92 if (size) { 93 if (pos >= size) 94 return 0; 95 if (pos + count > size) 96 count = size - pos; 97 } 98 99 if (!battr->read) 100 return -EIO; 101 102 return battr->read(of->file, kobj, battr, buf, pos, count); 103 } 104 105 /* kernfs read callback for regular sysfs files with pre-alloc */ 106 static ssize_t sysfs_kf_read(struct kernfs_open_file *of, char *buf, 107 size_t count, loff_t pos) 108 { 109 const struct sysfs_ops *ops = sysfs_file_ops(of->kn); 110 struct kobject *kobj = of->kn->parent->priv; 111 size_t len; 112 113 /* 114 * If buf != of->prealloc_buf, we don't know how 115 * large it is, so cannot safely pass it to ->show 116 */ 117 if (pos || WARN_ON_ONCE(buf != of->prealloc_buf)) 118 return 0; 119 len = ops->show(kobj, of->kn->priv, buf); 120 return min(count, len); 121 } 122 123 /* kernfs write callback for regular sysfs files */ 124 static ssize_t sysfs_kf_write(struct kernfs_open_file *of, char *buf, 125 size_t count, loff_t pos) 126 { 127 const struct sysfs_ops *ops = sysfs_file_ops(of->kn); 128 struct kobject *kobj = of->kn->parent->priv; 129 130 if (!count) 131 return 0; 132 133 return ops->store(kobj, of->kn->priv, buf, count); 134 } 135 136 /* kernfs write callback for bin sysfs files */ 137 static ssize_t sysfs_kf_bin_write(struct kernfs_open_file *of, char *buf, 138 size_t count, loff_t pos) 139 { 140 struct bin_attribute *battr = of->kn->priv; 141 struct kobject *kobj = of->kn->parent->priv; 142 loff_t size = file_inode(of->file)->i_size; 143 144 if (size) { 145 if (size <= pos) 146 return -EFBIG; 147 count = min_t(ssize_t, count, size - pos); 148 } 149 if (!count) 150 return 0; 151 152 if (!battr->write) 153 return -EIO; 154 155 return battr->write(of->file, kobj, battr, buf, pos, count); 156 } 157 158 static int sysfs_kf_bin_mmap(struct kernfs_open_file *of, 159 struct vm_area_struct *vma) 160 { 161 struct bin_attribute *battr = of->kn->priv; 162 struct kobject *kobj = of->kn->parent->priv; 163 164 return battr->mmap(of->file, kobj, battr, vma); 165 } 166 167 void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr) 168 { 169 struct kernfs_node *kn = kobj->sd, *tmp; 170 171 if (kn && dir) 172 kn = kernfs_find_and_get(kn, dir); 173 else 174 kernfs_get(kn); 175 176 if (kn && attr) { 177 tmp = kernfs_find_and_get(kn, attr); 178 kernfs_put(kn); 179 kn = tmp; 180 } 181 182 if (kn) { 183 kernfs_notify(kn); 184 kernfs_put(kn); 185 } 186 } 187 EXPORT_SYMBOL_GPL(sysfs_notify); 188 189 static const struct kernfs_ops sysfs_file_kfops_empty = { 190 }; 191 192 static const struct kernfs_ops sysfs_file_kfops_ro = { 193 .seq_show = sysfs_kf_seq_show, 194 }; 195 196 static const struct kernfs_ops sysfs_file_kfops_wo = { 197 .write = sysfs_kf_write, 198 }; 199 200 static const struct kernfs_ops sysfs_file_kfops_rw = { 201 .seq_show = sysfs_kf_seq_show, 202 .write = sysfs_kf_write, 203 }; 204 205 static const struct kernfs_ops sysfs_prealloc_kfops_ro = { 206 .read = sysfs_kf_read, 207 .prealloc = true, 208 }; 209 210 static const struct kernfs_ops sysfs_prealloc_kfops_wo = { 211 .write = sysfs_kf_write, 212 .prealloc = true, 213 }; 214 215 static const struct kernfs_ops sysfs_prealloc_kfops_rw = { 216 .read = sysfs_kf_read, 217 .write = sysfs_kf_write, 218 .prealloc = true, 219 }; 220 221 static const struct kernfs_ops sysfs_bin_kfops_ro = { 222 .read = sysfs_kf_bin_read, 223 }; 224 225 static const struct kernfs_ops sysfs_bin_kfops_wo = { 226 .write = sysfs_kf_bin_write, 227 }; 228 229 static const struct kernfs_ops sysfs_bin_kfops_rw = { 230 .read = sysfs_kf_bin_read, 231 .write = sysfs_kf_bin_write, 232 }; 233 234 static const struct kernfs_ops sysfs_bin_kfops_mmap = { 235 .read = sysfs_kf_bin_read, 236 .write = sysfs_kf_bin_write, 237 .mmap = sysfs_kf_bin_mmap, 238 }; 239 240 int sysfs_add_file_mode_ns(struct kernfs_node *parent, 241 const struct attribute *attr, bool is_bin, 242 umode_t mode, const void *ns) 243 { 244 struct lock_class_key *key = NULL; 245 const struct kernfs_ops *ops; 246 struct kernfs_node *kn; 247 loff_t size; 248 249 if (!is_bin) { 250 struct kobject *kobj = parent->priv; 251 const struct sysfs_ops *sysfs_ops = kobj->ktype->sysfs_ops; 252 253 /* every kobject with an attribute needs a ktype assigned */ 254 if (WARN(!sysfs_ops, KERN_ERR 255 "missing sysfs attribute operations for kobject: %s\n", 256 kobject_name(kobj))) 257 return -EINVAL; 258 259 if (sysfs_ops->show && sysfs_ops->store) { 260 if (mode & SYSFS_PREALLOC) 261 ops = &sysfs_prealloc_kfops_rw; 262 else 263 ops = &sysfs_file_kfops_rw; 264 } else if (sysfs_ops->show) { 265 if (mode & SYSFS_PREALLOC) 266 ops = &sysfs_prealloc_kfops_ro; 267 else 268 ops = &sysfs_file_kfops_ro; 269 } else if (sysfs_ops->store) { 270 if (mode & SYSFS_PREALLOC) 271 ops = &sysfs_prealloc_kfops_wo; 272 else 273 ops = &sysfs_file_kfops_wo; 274 } else 275 ops = &sysfs_file_kfops_empty; 276 277 size = PAGE_SIZE; 278 } else { 279 struct bin_attribute *battr = (void *)attr; 280 281 if (battr->mmap) 282 ops = &sysfs_bin_kfops_mmap; 283 else if (battr->read && battr->write) 284 ops = &sysfs_bin_kfops_rw; 285 else if (battr->read) 286 ops = &sysfs_bin_kfops_ro; 287 else if (battr->write) 288 ops = &sysfs_bin_kfops_wo; 289 else 290 ops = &sysfs_file_kfops_empty; 291 292 size = battr->size; 293 } 294 295 #ifdef CONFIG_DEBUG_LOCK_ALLOC 296 if (!attr->ignore_lockdep) 297 key = attr->key ?: (struct lock_class_key *)&attr->skey; 298 #endif 299 kn = __kernfs_create_file(parent, attr->name, mode & 0777, size, ops, 300 (void *)attr, ns, key); 301 if (IS_ERR(kn)) { 302 if (PTR_ERR(kn) == -EEXIST) 303 sysfs_warn_dup(parent, attr->name); 304 return PTR_ERR(kn); 305 } 306 return 0; 307 } 308 309 int sysfs_add_file(struct kernfs_node *parent, const struct attribute *attr, 310 bool is_bin) 311 { 312 return sysfs_add_file_mode_ns(parent, attr, is_bin, attr->mode, NULL); 313 } 314 315 /** 316 * sysfs_create_file_ns - create an attribute file for an object with custom ns 317 * @kobj: object we're creating for 318 * @attr: attribute descriptor 319 * @ns: namespace the new file should belong to 320 */ 321 int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr, 322 const void *ns) 323 { 324 BUG_ON(!kobj || !kobj->sd || !attr); 325 326 return sysfs_add_file_mode_ns(kobj->sd, attr, false, attr->mode, ns); 327 328 } 329 EXPORT_SYMBOL_GPL(sysfs_create_file_ns); 330 331 int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr) 332 { 333 int err = 0; 334 int i; 335 336 for (i = 0; ptr[i] && !err; i++) 337 err = sysfs_create_file(kobj, ptr[i]); 338 if (err) 339 while (--i >= 0) 340 sysfs_remove_file(kobj, ptr[i]); 341 return err; 342 } 343 EXPORT_SYMBOL_GPL(sysfs_create_files); 344 345 /** 346 * sysfs_add_file_to_group - add an attribute file to a pre-existing group. 347 * @kobj: object we're acting for. 348 * @attr: attribute descriptor. 349 * @group: group name. 350 */ 351 int sysfs_add_file_to_group(struct kobject *kobj, 352 const struct attribute *attr, const char *group) 353 { 354 struct kernfs_node *parent; 355 int error; 356 357 if (group) { 358 parent = kernfs_find_and_get(kobj->sd, group); 359 } else { 360 parent = kobj->sd; 361 kernfs_get(parent); 362 } 363 364 if (!parent) 365 return -ENOENT; 366 367 error = sysfs_add_file(parent, attr, false); 368 kernfs_put(parent); 369 370 return error; 371 } 372 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group); 373 374 /** 375 * sysfs_chmod_file - update the modified mode value on an object attribute. 376 * @kobj: object we're acting for. 377 * @attr: attribute descriptor. 378 * @mode: file permissions. 379 * 380 */ 381 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr, 382 umode_t mode) 383 { 384 struct kernfs_node *kn; 385 struct iattr newattrs; 386 int rc; 387 388 kn = kernfs_find_and_get(kobj->sd, attr->name); 389 if (!kn) 390 return -ENOENT; 391 392 newattrs.ia_mode = (mode & S_IALLUGO) | (kn->mode & ~S_IALLUGO); 393 newattrs.ia_valid = ATTR_MODE; 394 395 rc = kernfs_setattr(kn, &newattrs); 396 397 kernfs_put(kn); 398 return rc; 399 } 400 EXPORT_SYMBOL_GPL(sysfs_chmod_file); 401 402 /** 403 * sysfs_remove_file_ns - remove an object attribute with a custom ns tag 404 * @kobj: object we're acting for 405 * @attr: attribute descriptor 406 * @ns: namespace tag of the file to remove 407 * 408 * Hash the attribute name and namespace tag and kill the victim. 409 */ 410 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr, 411 const void *ns) 412 { 413 struct kernfs_node *parent = kobj->sd; 414 415 kernfs_remove_by_name_ns(parent, attr->name, ns); 416 } 417 EXPORT_SYMBOL_GPL(sysfs_remove_file_ns); 418 419 /** 420 * sysfs_remove_file_self - remove an object attribute from its own method 421 * @kobj: object we're acting for 422 * @attr: attribute descriptor 423 * 424 * See kernfs_remove_self() for details. 425 */ 426 bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr) 427 { 428 struct kernfs_node *parent = kobj->sd; 429 struct kernfs_node *kn; 430 bool ret; 431 432 kn = kernfs_find_and_get(parent, attr->name); 433 if (WARN_ON_ONCE(!kn)) 434 return false; 435 436 ret = kernfs_remove_self(kn); 437 438 kernfs_put(kn); 439 return ret; 440 } 441 442 void sysfs_remove_files(struct kobject *kobj, const struct attribute **ptr) 443 { 444 int i; 445 for (i = 0; ptr[i]; i++) 446 sysfs_remove_file(kobj, ptr[i]); 447 } 448 EXPORT_SYMBOL_GPL(sysfs_remove_files); 449 450 /** 451 * sysfs_remove_file_from_group - remove an attribute file from a group. 452 * @kobj: object we're acting for. 453 * @attr: attribute descriptor. 454 * @group: group name. 455 */ 456 void sysfs_remove_file_from_group(struct kobject *kobj, 457 const struct attribute *attr, const char *group) 458 { 459 struct kernfs_node *parent; 460 461 if (group) { 462 parent = kernfs_find_and_get(kobj->sd, group); 463 } else { 464 parent = kobj->sd; 465 kernfs_get(parent); 466 } 467 468 if (parent) { 469 kernfs_remove_by_name(parent, attr->name); 470 kernfs_put(parent); 471 } 472 } 473 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group); 474 475 /** 476 * sysfs_create_bin_file - create binary file for object. 477 * @kobj: object. 478 * @attr: attribute descriptor. 479 */ 480 int sysfs_create_bin_file(struct kobject *kobj, 481 const struct bin_attribute *attr) 482 { 483 BUG_ON(!kobj || !kobj->sd || !attr); 484 485 return sysfs_add_file(kobj->sd, &attr->attr, true); 486 } 487 EXPORT_SYMBOL_GPL(sysfs_create_bin_file); 488 489 /** 490 * sysfs_remove_bin_file - remove binary file for object. 491 * @kobj: object. 492 * @attr: attribute descriptor. 493 */ 494 void sysfs_remove_bin_file(struct kobject *kobj, 495 const struct bin_attribute *attr) 496 { 497 kernfs_remove_by_name(kobj->sd, attr->attr.name); 498 } 499 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file); 500