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