fs/cachefiles/daemon.c

   1 /* Daemon interface
   2  *
   3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public Licence
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the Licence, or (at your option) any later version.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/sched.h>
  15 #include <linux/completion.h>
  16 #include <linux/slab.h>
  17 #include <linux/fs.h>
  18 #include <linux/file.h>
  19 #include <linux/namei.h>
  20 #include <linux/poll.h>
  21 #include <linux/mount.h>
  22 #include <linux/statfs.h>
  23 #include <linux/ctype.h>
  24 #include <linux/string.h>
  25 #include <linux/fs_struct.h>
  26 #include "internal.h"
  27
  28 static int cachefiles_daemon_open(struct inode *, struct file *);
  29 static int cachefiles_daemon_release(struct inode *, struct file *);
  30 static ssize_t cachefiles_daemon_read(struct file *, char __user *, size_t,
  31                                       loff_t *);
  32 static ssize_t cachefiles_daemon_write(struct file *, const char __user *,
  33                                        size_t, loff_t *);
  34 static unsigned int cachefiles_daemon_poll(struct file *,
  35                                            struct poll_table_struct *);
  36 static int cachefiles_daemon_frun(struct cachefiles_cache *, char *);
  37 static int cachefiles_daemon_fcull(struct cachefiles_cache *, char *);
  38 static int cachefiles_daemon_fstop(struct cachefiles_cache *, char *);
  39 static int cachefiles_daemon_brun(struct cachefiles_cache *, char *);
  40 static int cachefiles_daemon_bcull(struct cachefiles_cache *, char *);
  41 static int cachefiles_daemon_bstop(struct cachefiles_cache *, char *);
  42 static int cachefiles_daemon_cull(struct cachefiles_cache *, char *);
  43 static int cachefiles_daemon_debug(struct cachefiles_cache *, char *);
  44 static int cachefiles_daemon_dir(struct cachefiles_cache *, char *);
  45 static int cachefiles_daemon_inuse(struct cachefiles_cache *, char *);
  46 static int cachefiles_daemon_secctx(struct cachefiles_cache *, char *);
  47 static int cachefiles_daemon_tag(struct cachefiles_cache *, char *);
  48
  49 static unsigned long cachefiles_open;
  50
  51 const struct file_operations cachefiles_daemon_fops = {
  52         .owner          = THIS_MODULE,
  53         .open           = cachefiles_daemon_open,
  54         .release        = cachefiles_daemon_release,
  55         .read           = cachefiles_daemon_read,
  56         .write          = cachefiles_daemon_write,
  57         .poll           = cachefiles_daemon_poll,
  58         .llseek         = noop_llseek,
  59 };
  60
  61 struct cachefiles_daemon_cmd {
  62         char name[8];
  63         int (*handler)(struct cachefiles_cache *cache, char *args);
  64 };
  65
  66 static const struct cachefiles_daemon_cmd cachefiles_daemon_cmds[] = {
  67         { "bind",       cachefiles_daemon_bind          },
  68         { "brun",       cachefiles_daemon_brun          },
  69         { "bcull",      cachefiles_daemon_bcull         },
  70         { "bstop",      cachefiles_daemon_bstop         },
  71         { "cull",       cachefiles_daemon_cull          },
  72         { "debug",      cachefiles_daemon_debug         },
  73         { "dir",        cachefiles_daemon_dir           },
  74         { "frun",       cachefiles_daemon_frun          },
  75         { "fcull",      cachefiles_daemon_fcull         },
  76         { "fstop",      cachefiles_daemon_fstop         },
  77         { "inuse",      cachefiles_daemon_inuse         },
  78         { "secctx",     cachefiles_daemon_secctx        },
  79         { "tag",        cachefiles_daemon_tag           },
  80         { "",           NULL                            }
  81 };
  82
  83
  84 /*
  85  * do various checks
  86  */
  87 static int cachefiles_daemon_open(struct inode *inode, struct file *file)
  88 {
  89         struct cachefiles_cache *cache;
  90
  91         _enter("");
  92
  93         /* only the superuser may do this */
  94         if (!capable(CAP_SYS_ADMIN))
  95                 return -EPERM;
  96
  97         /* the cachefiles device may only be open once at a time */
  98         if (xchg(&cachefiles_open, 1) == 1)
  99                 return -EBUSY;
 100
 101         /* allocate a cache record */
 102         cache = kzalloc(sizeof(struct cachefiles_cache), GFP_KERNEL);
 103         if (!cache) {
 104                 cachefiles_open = 0;
 105                 return -ENOMEM;
 106         }
 107
 108         mutex_init(&cache->daemon_mutex);
 109         cache->active_nodes = RB_ROOT;
 110         rwlock_init(&cache->active_lock);
 111         init_waitqueue_head(&cache->daemon_pollwq);
 112
 113         /* set default caching limits
 114          * - limit at 1% free space and/or free files
 115          * - cull below 5% free space and/or free files
 116          * - cease culling above 7% free space and/or free files
 117          */
 118         cache->frun_percent = 7;
 119         cache->fcull_percent = 5;
 120         cache->fstop_percent = 1;
 121         cache->brun_percent = 7;
 122         cache->bcull_percent = 5;
 123         cache->bstop_percent = 1;
 124
 125         file->private_data = cache;
 126         cache->cachefilesd = file;
 127         return 0;
 128 }
 129
 130 /*
 131  * release a cache
 132  */
 133 static int cachefiles_daemon_release(struct inode *inode, struct file *file)
 134 {
 135         struct cachefiles_cache *cache = file->private_data;
 136
 137         _enter("");
 138
 139         ASSERT(cache);
 140
 141         set_bit(CACHEFILES_DEAD, &cache->flags);
 142
 143         cachefiles_daemon_unbind(cache);
 144
 145         ASSERT(!cache->active_nodes.rb_node);
 146
 147         /* clean up the control file interface */
 148         cache->cachefilesd = NULL;
 149         file->private_data = NULL;
 150         cachefiles_open = 0;
 151
 152         kfree(cache);
 153
 154         _leave("");
 155         return 0;
 156 }
 157
 158 /*
 159  * read the cache state
 160  */
 161 static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer,
 162                                       size_t buflen, loff_t *pos)
 163 {
 164         struct cachefiles_cache *cache = file->private_data;
 165         char buffer[256];
 166         int n;
 167
 168         //_enter(",,%zu,", buflen);
 169
 170         if (!test_bit(CACHEFILES_READY, &cache->flags))
 171                 return 0;
 172
 173         /* check how much space the cache has */
 174         cachefiles_has_space(cache, 0, 0);
 175
 176         /* summarise */
 177         clear_bit(CACHEFILES_STATE_CHANGED, &cache->flags);
 178
 179         n = snprintf(buffer, sizeof(buffer),
 180                      "cull=%c"
 181                      " frun=%llx"
 182                      " fcull=%llx"
 183                      " fstop=%llx"
 184                      " brun=%llx"
 185                      " bcull=%llx"
 186                      " bstop=%llx",
 187                      test_bit(CACHEFILES_CULLING, &cache->flags) ? '1' : '0',
 188                      (unsigned long long) cache->frun,
 189                      (unsigned long long) cache->fcull,
 190                      (unsigned long long) cache->fstop,
 191                      (unsigned long long) cache->brun,
 192                      (unsigned long long) cache->bcull,
 193                      (unsigned long long) cache->bstop
 194                      );
 195
 196         if (n > buflen)
 197                 return -EMSGSIZE;
 198
 199         if (copy_to_user(_buffer, buffer, n) != 0)
 200                 return -EFAULT;
 201
 202         return n;
 203 }
 204
 205 /*
 206  * command the cache
 207  */
 208 static ssize_t cachefiles_daemon_write(struct file *file,
 209                                        const char __user *_data,
 210                                        size_t datalen,
 211                                        loff_t *pos)
 212 {
 213         const struct cachefiles_daemon_cmd *cmd;
 214         struct cachefiles_cache *cache = file->private_data;
 215         ssize_t ret;
 216         char *data, *args, *cp;
 217
 218         //_enter(",,%zu,", datalen);
 219
 220         ASSERT(cache);
 221
 222         if (test_bit(CACHEFILES_DEAD, &cache->flags))
 223                 return -EIO;
 224
 225         if (datalen < 0 || datalen > PAGE_SIZE - 1)
 226                 return -EOPNOTSUPP;
 227
 228         /* drag the command string into the kernel so we can parse it */
 229         data = memdup_user_nul(_data, datalen);
 230         if (IS_ERR(data))
 231                 return PTR_ERR(data);
 232
 233         ret = -EINVAL;
 234         if (memchr(data, '\0', datalen))
 235                 goto error;
 236
 237         /* strip any newline */
 238         cp = memchr(data, '\n', datalen);
 239         if (cp) {
 240                 if (cp == data)
 241                         goto error;
 242
 243                 *cp = '\0';
 244         }
 245
 246         /* parse the command */
 247         ret = -EOPNOTSUPP;
 248
 249         for (args = data; *args; args++)
 250                 if (isspace(*args))
 251                         break;
 252         if (*args) {
 253                 if (args == data)
 254                         goto error;
 255                 *args = '\0';
 256                 args = skip_spaces(++args);
 257         }
 258
 259         /* run the appropriate command handler */
 260         for (cmd = cachefiles_daemon_cmds; cmd->name[0]; cmd++)
 261                 if (strcmp(cmd->name, data) == 0)
 262                         goto found_command;
 263
 264 error:
 265         kfree(data);
 266         //_leave(" = %zd", ret);
 267         return ret;
 268
 269 found_command:
 270         mutex_lock(&cache->daemon_mutex);
 271
 272         ret = -EIO;
 273         if (!test_bit(CACHEFILES_DEAD, &cache->flags))
 274                 ret = cmd->handler(cache, args);
 275
 276         mutex_unlock(&cache->daemon_mutex);
 277
 278         if (ret == 0)
 279                 ret = datalen;
 280         goto error;
 281 }
 282
 283 /*
 284  * poll for culling state
 285  * - use POLLOUT to indicate culling state
 286  */
 287 static unsigned int cachefiles_daemon_poll(struct file *file,
 288                                            struct poll_table_struct *poll)
 289 {
 290         struct cachefiles_cache *cache = file->private_data;
 291         unsigned int mask;
 292
 293         poll_wait(file, &cache->daemon_pollwq, poll);
 294         mask = 0;
 295
 296         if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags))
 297                 mask |= POLLIN;
 298
 299         if (test_bit(CACHEFILES_CULLING, &cache->flags))
 300                 mask |= POLLOUT;
 301
 302         return mask;
 303 }
 304
 305 /*
 306  * give a range error for cache space constraints
 307  * - can be tail-called
 308  */
 309 static int cachefiles_daemon_range_error(struct cachefiles_cache *cache,
 310                                          char *args)
 311 {
 312         pr_err("Free space limits must be in range 0%%<=stop<cull<run<100%%\n");
 313
 314         return -EINVAL;
 315 }
 316
 317 /*
 318  * set the percentage of files at which to stop culling
 319  * - command: "frun <N>%"
 320  */
 321 static int cachefiles_daemon_frun(struct cachefiles_cache *cache, char *args)
 322 {
 323         unsigned long frun;
 324
 325         _enter(",%s", args);
 326
 327         if (!*args)
 328                 return -EINVAL;
 329
 330         frun = simple_strtoul(args, &args, 10);
 331         if (args[0] != '%' || args[1] != '\0')
 332                 return -EINVAL;
 333
 334         if (frun <= cache->fcull_percent || frun >= 100)
 335                 return cachefiles_daemon_range_error(cache, args);
 336
 337         cache->frun_percent = frun;
 338         return 0;
 339 }
 340
 341 /*
 342  * set the percentage of files at which to start culling
 343  * - command: "fcull <N>%"
 344  */
 345 static int cachefiles_daemon_fcull(struct cachefiles_cache *cache, char *args)
 346 {
 347         unsigned long fcull;
 348
 349         _enter(",%s", args);
 350
 351         if (!*args)
 352                 return -EINVAL;
 353
 354         fcull = simple_strtoul(args, &args, 10);
 355         if (args[0] != '%' || args[1] != '\0')
 356                 return -EINVAL;
 357
 358         if (fcull <= cache->fstop_percent || fcull >= cache->frun_percent)
 359                 return cachefiles_daemon_range_error(cache, args);
 360
 361         cache->fcull_percent = fcull;
 362         return 0;
 363 }
 364
 365 /*
 366  * set the percentage of files at which to stop allocating
 367  * - command: "fstop <N>%"
 368  */
 369 static int cachefiles_daemon_fstop(struct cachefiles_cache *cache, char *args)
 370 {
 371         unsigned long fstop;
 372
 373         _enter(",%s", args);
 374
 375         if (!*args)
 376                 return -EINVAL;
 377
 378         fstop = simple_strtoul(args, &args, 10);
 379         if (args[0] != '%' || args[1] != '\0')
 380                 return -EINVAL;
 381
 382         if (fstop < 0 || fstop >= cache->fcull_percent)
 383                 return cachefiles_daemon_range_error(cache, args);
 384
 385         cache->fstop_percent = fstop;
 386         return 0;
 387 }
 388
 389 /*
 390  * set the percentage of blocks at which to stop culling
 391  * - command: "brun <N>%"
 392  */
 393 static int cachefiles_daemon_brun(struct cachefiles_cache *cache, char *args)
 394 {
 395         unsigned long brun;
 396
 397         _enter(",%s", args);
 398
 399         if (!*args)
 400                 return -EINVAL;
 401
 402         brun = simple_strtoul(args, &args, 10);
 403         if (args[0] != '%' || args[1] != '\0')
 404                 return -EINVAL;
 405
 406         if (brun <= cache->bcull_percent || brun >= 100)
 407                 return cachefiles_daemon_range_error(cache, args);
 408
 409         cache->brun_percent = brun;
 410         return 0;
 411 }
 412
 413 /*
 414  * set the percentage of blocks at which to start culling
 415  * - command: "bcull <N>%"
 416  */
 417 static int cachefiles_daemon_bcull(struct cachefiles_cache *cache, char *args)
 418 {
 419         unsigned long bcull;
 420
 421         _enter(",%s", args);
 422
 423         if (!*args)
 424                 return -EINVAL;
 425
 426         bcull = simple_strtoul(args, &args, 10);
 427         if (args[0] != '%' || args[1] != '\0')
 428                 return -EINVAL;
 429
 430         if (bcull <= cache->bstop_percent || bcull >= cache->brun_percent)
 431                 return cachefiles_daemon_range_error(cache, args);
 432
 433         cache->bcull_percent = bcull;
 434         return 0;
 435 }
 436
 437 /*
 438  * set the percentage of blocks at which to stop allocating
 439  * - command: "bstop <N>%"
 440  */
 441 static int cachefiles_daemon_bstop(struct cachefiles_cache *cache, char *args)
 442 {
 443         unsigned long bstop;
 444
 445         _enter(",%s", args);
 446
 447         if (!*args)
 448                 return -EINVAL;
 449
 450         bstop = simple_strtoul(args, &args, 10);
 451         if (args[0] != '%' || args[1] != '\0')
 452                 return -EINVAL;
 453
 454         if (bstop < 0 || bstop >= cache->bcull_percent)
 455                 return cachefiles_daemon_range_error(cache, args);
 456
 457         cache->bstop_percent = bstop;
 458         return 0;
 459 }
 460
 461 /*
 462  * set the cache directory
 463  * - command: "dir <name>"
 464  */
 465 static int cachefiles_daemon_dir(struct cachefiles_cache *cache, char *args)
 466 {
 467         char *dir;
 468
 469         _enter(",%s", args);
 470
 471         if (!*args) {
 472                 pr_err("Empty directory specified\n");
 473                 return -EINVAL;
 474         }
 475
 476         if (cache->rootdirname) {
 477                 pr_err("Second cache directory specified\n");
 478                 return -EEXIST;
 479         }
 480
 481         dir = kstrdup(args, GFP_KERNEL);
 482         if (!dir)
 483                 return -ENOMEM;
 484
 485         cache->rootdirname = dir;
 486         return 0;
 487 }
 488
 489 /*
 490  * set the cache security context
 491  * - command: "secctx <ctx>"
 492  */
 493 static int cachefiles_daemon_secctx(struct cachefiles_cache *cache, char *args)
 494 {
 495         char *secctx;
 496
 497         _enter(",%s", args);
 498
 499         if (!*args) {
 500                 pr_err("Empty security context specified\n");
 501                 return -EINVAL;
 502         }
 503
 504         if (cache->secctx) {
 505                 pr_err("Second security context specified\n");
 506                 return -EINVAL;
 507         }
 508
 509         secctx = kstrdup(args, GFP_KERNEL);
 510         if (!secctx)
 511                 return -ENOMEM;
 512
 513         cache->secctx = secctx;
 514         return 0;
 515 }
 516
 517 /*
 518  * set the cache tag
 519  * - command: "tag <name>"
 520  */
 521 static int cachefiles_daemon_tag(struct cachefiles_cache *cache, char *args)
 522 {
 523         char *tag;
 524
 525         _enter(",%s", args);
 526
 527         if (!*args) {
 528                 pr_err("Empty tag specified\n");
 529                 return -EINVAL;
 530         }
 531
 532         if (cache->tag)
 533                 return -EEXIST;
 534
 535         tag = kstrdup(args, GFP_KERNEL);
 536         if (!tag)
 537                 return -ENOMEM;
 538
 539         cache->tag = tag;
 540         return 0;
 541 }
 542
 543 /*
 544  * request a node in the cache be culled from the current working directory
 545  * - command: "cull <name>"
 546  */
 547 static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
 548 {
 549         struct path path;
 550         const struct cred *saved_cred;
 551         int ret;
 552
 553         _enter(",%s", args);
 554
 555         if (strchr(args, '/'))
 556                 goto inval;
 557
 558         if (!test_bit(CACHEFILES_READY, &cache->flags)) {
 559                 pr_err("cull applied to unready cache\n");
 560                 return -EIO;
 561         }
 562
 563         if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
 564                 pr_err("cull applied to dead cache\n");
 565                 return -EIO;
 566         }
 567
 568         /* extract the directory dentry from the cwd */
 569         get_fs_pwd(current->fs, &path);
 570
 571         if (!d_can_lookup(path.dentry))
 572                 goto notdir;
 573
 574         cachefiles_begin_secure(cache, &saved_cred);
 575         ret = cachefiles_cull(cache, path.dentry, args);
 576         cachefiles_end_secure(cache, saved_cred);
 577
 578         path_put(&path);
 579         _leave(" = %d", ret);
 580         return ret;
 581
 582 notdir:
 583         path_put(&path);
 584         pr_err("cull command requires dirfd to be a directory\n");
 585         return -ENOTDIR;
 586
 587 inval:
 588         pr_err("cull command requires dirfd and filename\n");
 589         return -EINVAL;
 590 }
 591
 592 /*
 593  * set debugging mode
 594  * - command: "debug <mask>"
 595  */
 596 static int cachefiles_daemon_debug(struct cachefiles_cache *cache, char *args)
 597 {
 598         unsigned long mask;
 599
 600         _enter(",%s", args);
 601
 602         mask = simple_strtoul(args, &args, 0);
 603         if (args[0] != '\0')
 604                 goto inval;
 605
 606         cachefiles_debug = mask;
 607         _leave(" = 0");
 608         return 0;
 609
 610 inval:
 611         pr_err("debug command requires mask\n");
 612         return -EINVAL;
 613 }
 614
 615 /*
 616  * find out whether an object in the current working directory is in use or not
 617  * - command: "inuse <name>"
 618  */
 619 static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
 620 {
 621         struct path path;
 622         const struct cred *saved_cred;
 623         int ret;
 624
 625         //_enter(",%s", args);
 626
 627         if (strchr(args, '/'))
 628                 goto inval;
 629
 630         if (!test_bit(CACHEFILES_READY, &cache->flags)) {
 631                 pr_err("inuse applied to unready cache\n");
 632                 return -EIO;
 633         }
 634
 635         if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
 636                 pr_err("inuse applied to dead cache\n");
 637                 return -EIO;
 638         }
 639
 640         /* extract the directory dentry from the cwd */
 641         get_fs_pwd(current->fs, &path);
 642
 643         if (!d_can_lookup(path.dentry))
 644                 goto notdir;
 645
 646         cachefiles_begin_secure(cache, &saved_cred);
 647         ret = cachefiles_check_in_use(cache, path.dentry, args);
 648         cachefiles_end_secure(cache, saved_cred);
 649
 650         path_put(&path);
 651         //_leave(" = %d", ret);
 652         return ret;
 653
 654 notdir:
 655         path_put(&path);
 656         pr_err("inuse command requires dirfd to be a directory\n");
 657         return -ENOTDIR;
 658
 659 inval:
 660         pr_err("inuse command requires dirfd and filename\n");
 661         return -EINVAL;
 662 }
 663
 664 /*
 665  * see if we have space for a number of pages and/or a number of files in the
 666  * cache
 667  */
 668 int cachefiles_has_space(struct cachefiles_cache *cache,
 669                          unsigned fnr, unsigned bnr)
 670 {
 671         struct kstatfs stats;
 672         struct path path = {
 673                 .mnt    = cache->mnt,
 674                 .dentry = cache->mnt->mnt_root,
 675         };
 676         int ret;
 677
 678         //_enter("{%llu,%llu,%llu,%llu,%llu,%llu},%u,%u",
 679         //       (unsigned long long) cache->frun,
 680         //       (unsigned long long) cache->fcull,
 681         //       (unsigned long long) cache->fstop,
 682         //       (unsigned long long) cache->brun,
 683         //       (unsigned long long) cache->bcull,
 684         //       (unsigned long long) cache->bstop,
 685         //       fnr, bnr);
 686
 687         /* find out how many pages of blockdev are available */
 688         memset(&stats, 0, sizeof(stats));
 689
 690         ret = vfs_statfs(&path, &stats);
 691         if (ret < 0) {
 692                 if (ret == -EIO)
 693                         cachefiles_io_error(cache, "statfs failed");
 694                 _leave(" = %d", ret);
 695                 return ret;
 696         }
 697
 698         stats.f_bavail >>= cache->bshift;
 699
 700         //_debug("avail %llu,%llu",
 701         //       (unsigned long long) stats.f_ffree,
 702         //       (unsigned long long) stats.f_bavail);
 703
 704         /* see if there is sufficient space */
 705         if (stats.f_ffree > fnr)
 706                 stats.f_ffree -= fnr;
 707         else
 708                 stats.f_ffree = 0;
 709
 710         if (stats.f_bavail > bnr)
 711                 stats.f_bavail -= bnr;
 712         else
 713                 stats.f_bavail = 0;
 714
 715         ret = -ENOBUFS;
 716         if (stats.f_ffree < cache->fstop ||
 717             stats.f_bavail < cache->bstop)
 718                 goto begin_cull;
 719
 720         ret = 0;
 721         if (stats.f_ffree < cache->fcull ||
 722             stats.f_bavail < cache->bcull)
 723                 goto begin_cull;
 724
 725         if (test_bit(CACHEFILES_CULLING, &cache->flags) &&
 726             stats.f_ffree >= cache->frun &&
 727             stats.f_bavail >= cache->brun &&
 728             test_and_clear_bit(CACHEFILES_CULLING, &cache->flags)
 729             ) {
 730                 _debug("cease culling");
 731                 cachefiles_state_changed(cache);
 732         }
 733
 734         //_leave(" = 0");
 735         return 0;
 736
 737 begin_cull:
 738         if (!test_and_set_bit(CACHEFILES_CULLING, &cache->flags)) {
 739                 _debug("### CULL CACHE ###");
 740                 cachefiles_state_changed(cache);
 741         }
 742
 743         _leave(" = %d", ret);
 744         return ret;
 745 }