fs/pohmelfs/stat.c

   1 /*
   2  * Copyright (C) 2011+ Evgeniy Polyakov <zbr@ioremap.net>
   3  */
   4
   5 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   6
   7 #include "pohmelfs.h"
   8
   9 static int pohmelfs_stat_init(struct pohmelfs_trans *t)
  10 {
  11         struct pohmelfs_wait *wait = t->priv;
  12
  13         atomic_long_inc(&wait->count);
  14         pohmelfs_wait_get(wait);
  15         return 0;
  16 }
  17
  18 static void pohmelfs_stat_destroy(struct pohmelfs_trans *t)
  19 {
  20         struct pohmelfs_wait *wait = t->priv;
  21
  22         atomic_long_dec(&wait->count);
  23         wake_up(&wait->wq);
  24         pohmelfs_wait_put(wait);
  25 }
  26
  27 static int pohmelfs_stat_complete(struct pohmelfs_trans *t, struct pohmelfs_state *recv)
  28 {
  29         struct pohmelfs_wait *wait = t->priv;
  30         struct dnet_cmd *cmd = &recv->cmd;
  31         struct dnet_attr *attr;
  32         int err = cmd->status;
  33
  34         if (err)
  35                 goto err_out_exit;
  36
  37         if (cmd->size != sizeof(struct dnet_attr) + sizeof(struct dnet_stat)) {
  38                 err = -ENOENT;
  39                 goto err_out_exit;
  40         }
  41
  42         attr = t->recv_data;
  43
  44         if ((cmd->flags & DNET_FLAGS_MORE) && (attr->cmd == DNET_CMD_STAT) && (attr->size == sizeof(struct dnet_stat))) {
  45                 struct dnet_stat *stat;
  46
  47                 stat = t->recv_data + sizeof(struct dnet_attr);
  48                 dnet_convert_stat(stat);
  49
  50                 recv->bsize = stat->bsize;
  51                 recv->frsize = stat->frsize;
  52                 recv->blocks = stat->blocks;
  53                 recv->bfree = stat->bfree;
  54                 recv->bavail = stat->bavail;
  55
  56                 pr_debug("%s: total: %llu, avail: %llu\n",
  57                          pohmelfs_dump_id(cmd->id.id),
  58                          (unsigned long long)(stat->frsize * stat->blocks / 1024 / 1024),
  59                          (unsigned long long)(stat->bavail * stat->bsize / 1024 / 1024));
  60         }
  61
  62 err_out_exit:
  63         if (err)
  64                 wait->condition = err;
  65         else
  66                 wait->condition = 1;
  67         wake_up(&wait->wq);
  68
  69         return 0;
  70 }
  71
  72 int pohmelfs_stat(struct pohmelfs_sb *psb, int sync)
  73 {
  74         struct pohmelfs_state **states, *st;
  75         struct pohmelfs_wait *wait;
  76         struct pohmelfs_io *pio;
  77         int err, i, num;
  78         long ret;
  79
  80         wait = pohmelfs_wait_alloc(psb->root);
  81         if (!wait) {
  82                 err = -ENOMEM;
  83                 goto err_out_exit;
  84         }
  85
  86         pio = kmem_cache_zalloc(pohmelfs_io_cache, GFP_NOIO);
  87         if (!pio) {
  88                 err = -ENOMEM;
  89                 goto err_out_put;
  90         }
  91
  92         err = pohmelfs_grab_states(psb, &states);
  93         if (err < 0)
  94                 goto err_out_free_pio;
  95
  96         pio->pi = psb->root;
  97         /* we use state pointer, but do not know correct ID, so use DIRECT flag here to forbid request forwarding */
  98         pio->cflags = DNET_FLAGS_NEED_ACK | DNET_FLAGS_NOLOCK | DNET_FLAGS_DIRECT;
  99         pio->cmd = DNET_CMD_STAT;
 100         pio->priv = wait;
 101         pio->cb.init = pohmelfs_stat_init;
 102         pio->cb.destroy = pohmelfs_stat_destroy;
 103         pio->cb.complete = pohmelfs_stat_complete;
 104
 105         num = err;
 106         for (i = 0; i < num; ++i) {
 107                 st = states[i];
 108
 109                 pio->group_id = st->group_id;
 110                 pio->id = &psb->root->id;
 111
 112                 err = pohmelfs_send_buf_single(pio, st);
 113                 pohmelfs_state_put(st);
 114         }
 115
 116         err = 0;
 117
 118         if (sync) {
 119                 ret = wait_event_interruptible_timeout(wait->wq,
 120                                 atomic_long_read(&wait->count) != 0,
 121                                 msecs_to_jiffies(psb->read_wait_timeout));
 122                 if (ret <= 0) {
 123                         err = ret;
 124                         if (ret == 0)
 125                                 err = -ETIMEDOUT;
 126                         goto err_out_free;
 127                 }
 128
 129                 if (wait->condition < 0)
 130                         err = wait->condition;
 131         }
 132
 133 err_out_free:
 134         kfree(states);
 135 err_out_free_pio:
 136         kmem_cache_free(pohmelfs_io_cache, pio);
 137 err_out_put:
 138         pohmelfs_wait_put(wait);
 139 err_out_exit:
 140         return err;
 141 }