fs/pohmelfs/dir.c

   1 /*
   2  * Copyright (C) 2011+ Evgeniy Polyakov <zbr@ioremap.net>
   3  */
   4
   5 #include <linux/fs.h>
   6 #include <linux/dcache.h>
   7
   8 #include "pohmelfs.h"
   9
  10 int pohmelfs_send_inode_info(struct pohmelfs_inode *pi, struct dnet_raw_id *id, const char *sname, int len, int overwrite)
  11 {
  12         struct pohmelfs_sb *psb = pohmelfs_sb(pi->vfs_inode.i_sb);
  13         struct pohmelfs_inode_info *info;
  14         struct pohmelfs_io io;
  15         char *dname;
  16         int err;
  17
  18         memset(&io, 0, sizeof(struct pohmelfs_io));
  19
  20         info = kmalloc(sizeof(struct pohmelfs_inode_info) + len, GFP_NOIO);
  21         if (!info) {
  22                 err = -ENOMEM;
  23                 goto err_out_exit;
  24         }
  25         dname = (char *)(info + 1);
  26
  27         pohmelfs_fill_inode_info(&pi->vfs_inode, info);
  28         info->namelen = len;
  29
  30         pohmelfs_hash(psb, sname, len, &info->name);
  31
  32         memcpy(dname, sname, len);
  33
  34         pohmelfs_convert_inode_info(info);
  35
  36         io.pi = pi;
  37         io.id = id;
  38         io.group = 2;
  39         io.cmd = DNET_CMD_WRITE;
  40         io.aflags = DNET_ATTR_NOCSUM;
  41         io.size = sizeof(struct pohmelfs_inode_info) + len;
  42         io.ioflags = DNET_IO_FLAGS_APPEND;
  43         io.data = info;
  44         io.alloc_flags = POHMELFS_IO_OWN;
  45
  46         err = pohmelfs_send_io(&io);
  47         pr_info("pohmelfs: pohmelfs_send_inode_info: %s: pohmelfs_send_io: object ino: %lu, name: %s, overwrite: %d, offset: %llu: %d\n",
  48                 pohmelfs_dump_id(id->id), pi->vfs_inode.i_ino, sname, overwrite, pi->offset, err);
  49
  50 err_out_exit:
  51         return err;
  52 }
  53
  54 static int pohmelfs_create(struct inode *dir, struct dentry *dentry, int mode,
  55                 struct nameidata *nd)
  56 {
  57         struct pohmelfs_sb *psb = pohmelfs_sb(dir->i_sb);
  58         struct pohmelfs_inode *parent = pohmelfs_inode(dir);
  59         struct pohmelfs_inode *pi;
  60         int err;
  61
  62         pi = pohmelfs_new_inode(psb, mode);
  63         if (IS_ERR(pi)) {
  64                 err = PTR_ERR(pi);
  65                 goto err_out_exit;
  66         }
  67
  68         memcpy(&pi->parent_id, &parent->id, sizeof(struct dnet_raw_id));
  69
  70         err = pohmelfs_send_inode_info(pi, &parent->id, dentry->d_name.name, dentry->d_name.len, 0);
  71         if (err)
  72                 goto err_out_put;
  73
  74         pr_info("pohmelfs: create: %s, ino: %lu, parent dir: %lu, object: %s\n",
  75                         pohmelfs_dump_id(pi->id.id), pi->vfs_inode.i_ino,
  76                         dir->i_ino, dentry->d_name.name);
  77
  78         inode_init_owner(&pi->vfs_inode, dir, mode);
  79
  80         /*
  81          * calling d_instantiate() implies that
  82          * ->lookup() used d_splice_alias() with NULL inode
  83          *  when it failed to find requested object
  84          */
  85         d_instantiate(dentry, &pi->vfs_inode);
  86
  87         return 0;
  88
  89 err_out_put:
  90         iput(&pi->vfs_inode);
  91 err_out_exit:
  92         return err;
  93 }
  94
  95 struct pohmelfs_lookup_priv {
  96         struct pohmelfs_wait            *wait;
  97
  98         struct kref                     refcnt;
  99
 100         /* if set, all received inodes will be attached to dentries in parent dir */
 101         int                             load_all;
 102
 103         /* currently read object name */
 104         u32                             namelen;
 105
 106         /* currently read inode info */
 107         long                            offset;
 108
 109         /*
 110          * this is the name we are looking for
 111          */
 112         struct dnet_raw_id              name_id;
 113
 114         int                             found;
 115         /*
 116          * will be filled, if inode with given name was found
 117          */
 118         struct dnet_raw_id              inode_id;
 119 };
 120
 121 static void pohmelfs_lookup_free(struct kref *kref)
 122 {
 123         struct pohmelfs_lookup_priv *priv = container_of(kref, struct pohmelfs_lookup_priv, refcnt);
 124
 125         if (priv->wait)
 126                 pohmelfs_wait_put(priv->wait);
 127         kfree(priv);
 128 }
 129
 130 static int pohmelfs_lookup_complete(struct pohmelfs_trans *t, struct pohmelfs_state *recv)
 131 {
 132         struct pohmelfs_lookup_priv *priv = t->priv;
 133         struct pohmelfs_wait *wait = priv->wait;
 134         struct dnet_cmd *cmd = &recv->cmd;
 135
 136         if (t->recv_data) {
 137                 kfree(t->recv_data);
 138                 t->recv_data = NULL;
 139         }
 140
 141         if (!(cmd->flags & DNET_FLAGS_MORE)) {
 142                 int err = cmd->status;
 143
 144                 if (!priv->found && !err && !priv->load_all)
 145                         err = -ENOENT;
 146
 147                 wait->condition = 1;
 148                 wake_up(&wait->wq);
 149
 150                 pohmelfs_print_addr(&recv->sa, "%s: pohmelfs_lookup_complete: %d\n",
 151                                 pohmelfs_dump_id(priv->name_id.id), err);
 152
 153                 kref_put(&priv->refcnt, pohmelfs_lookup_free);
 154
 155                 return err;
 156         }
 157
 158         return 0;
 159 }
 160
 161 static int pohmelfs_lookup_dentry(struct pohmelfs_lookup_priv *priv, struct pohmelfs_inode *pi, char *name)
 162 {
 163         struct inode *inode = &pi->vfs_inode;
 164         struct inode *dir = &priv->wait->pi->vfs_inode;
 165         struct dentry *dentry, *parent_dentry, *old;
 166         struct qstr str;
 167         int err;
 168
 169         str.name = name;
 170         str.len = priv->namelen;
 171         str.hash = full_name_hash(str.name, str.len);
 172
 173         name[str.len] = '\0';
 174
 175         /* we do not need to hold dir->i_mutex here, don't we? :) */
 176         parent_dentry = d_find_alias(dir);
 177         if (!parent_dentry) {
 178                 err = -ENOENT;
 179                 goto read_name_out_unlock;
 180         }
 181
 182         dentry = d_lookup(parent_dentry, &str);
 183         if (dentry) {
 184                 err = -EEXIST;
 185                 dput(dentry);
 186                 goto read_name_out_put_parent;
 187         }
 188         /*
 189          * if things are ok, dentry has 2 references -
 190          * one in parent dir, and another its own,
 191          * which we should drop
 192          */
 193         dentry = d_alloc(parent_dentry, &str);
 194         if (!dentry) {
 195                 err = -ENOMEM;
 196                 goto read_name_out_put_parent;
 197         }
 198
 199         old = d_splice_alias(inode, dentry);
 200         if (unlikely(old)) {
 201                 dput(dentry);
 202                 dentry = old;
 203         } else {
 204                 dput(dentry);
 205         }
 206
 207         dput(parent_dentry);
 208         return 0;
 209
 210 read_name_out_put_parent:
 211         dput(parent_dentry);
 212 read_name_out_unlock:
 213         iput(inode);
 214
 215         return err;
 216 }
 217
 218 static int pohmelfs_lookup_recv_inode(struct pohmelfs_trans *t, struct pohmelfs_state *recv)
 219 {
 220         struct pohmelfs_lookup_priv *priv = t->priv;
 221         u32 iisize = sizeof(struct pohmelfs_inode_info) + priv->namelen;
 222         int attr_size = sizeof(struct dnet_attr) + sizeof(struct dnet_io_attr);
 223         struct pohmelfs_sb *psb = pohmelfs_sb(t->inode->i_sb);
 224         struct pohmelfs_inode_info *info = t->recv_data;
 225         struct pohmelfs_inode *pi;
 226         struct inode *inode;
 227         char *name;
 228         int err;
 229
 230         /* reading name which follows inode_info */
 231         err = pohmelfs_data_recv(recv, t->recv_data + priv->offset, iisize - priv->offset, MSG_DONTWAIT);
 232         if (err < 0)
 233                 goto err_out_exit;
 234
 235         t->recv_offset += err;
 236         priv->offset += err;
 237
 238         if (priv->offset < iisize) {
 239                 err = -EAGAIN;
 240                 goto err_out_exit;
 241         }
 242
 243         name = (char *)(info + 1);
 244         /* we allocated enough space for this */
 245         name[priv->namelen] = '\0';
 246
 247         pohmelfs_print_addr(&recv->sa, "name: %s: ino: %llu, removed: %d, name: %s, namelen: %u, size: %llu\n",
 248                         pohmelfs_dump_id(info->name.id), (unsigned long long)info->ino,
 249                         !!(info->flags & POHMELFS_INODE_INFO_REMOVED), name, priv->namelen,
 250                         (unsigned long long)info->size);
 251
 252         if (info->flags & POHMELFS_INODE_INFO_REMOVED) {
 253                 err = -ENOENT;
 254                 goto err_out_done;
 255         }
 256
 257         pi = pohmelfs_sb_inode_lookup(psb, &info->id);
 258         if (pi) {
 259                 inode = &pi->vfs_inode;
 260
 261                 pohmelfs_fill_inode(inode, info);
 262                 iput(inode);
 263
 264                 err = -EEXIST;
 265                 goto err_out_done;
 266         } else {
 267                 pi = pohmelfs_existing_inode(recv->psb, info);
 268                 if (IS_ERR(pi)) {
 269                         err = PTR_ERR(pi);
 270                         goto err_out_done;
 271                 }
 272
 273                 memcpy(&pi->parent_id, &priv->wait->pi->id, sizeof(struct dnet_raw_id));
 274
 275                 pi->offset = t->recv_offset - sizeof(struct pohmelfs_inode_info) - attr_size;
 276
 277                 if (priv->load_all) {
 278                         pohmelfs_lookup_dentry(priv, pi, name);
 279                 } else {
 280                         if (!memcmp(&info->name, &priv->name_id, sizeof(struct dnet_raw_id))) {
 281                                 if (!priv->found)
 282                                         memcpy(&priv->inode_id, &pi->id, sizeof(struct dnet_raw_id));
 283                                 priv->found = 1;
 284                         } else {
 285                                 pohmelfs_lookup_dentry(priv, pi, name);
 286                         }
 287                 }
 288         }
 289
 290         err = 0;
 291
 292 err_out_done:
 293         priv->namelen = 0;
 294         priv->offset = 0;
 295 err_out_exit:
 296         return err;
 297 }
 298
 299 static int pohmelfs_lookup_recv_reply(struct pohmelfs_trans *t, struct pohmelfs_state *recv)
 300 {
 301         struct pohmelfs_lookup_priv *priv = t->priv;
 302         struct dnet_cmd *cmd = &recv->cmd;
 303         int attr_size = sizeof(struct dnet_attr) + sizeof(struct dnet_io_attr);
 304         int err = 0;
 305
 306         if (!t->recv_data) {
 307                 t->recv_data = kmalloc(sizeof(struct pohmelfs_inode_info) + NAME_MAX + 1, GFP_NOIO);
 308                 if (!t->recv_data) {
 309                         err = -ENOMEM;
 310                         goto err_out_exit;
 311                 }
 312
 313                 pohmelfs_print_addr(&recv->sa, "name: %s: recv_data: %p, cmd size: %llu\n",
 314                         pohmelfs_dump_id(priv->name_id.id), t->recv_data, (unsigned long long)cmd->size);
 315         }
 316
 317         if (t->recv_offset < attr_size) {
 318                 void *attr = &t->cmd.attr;
 319
 320                 err = pohmelfs_data_recv(recv, attr + t->recv_offset, attr_size - t->recv_offset, MSG_DONTWAIT);
 321                 if (err < 0)
 322                         goto err_out_exit;
 323                 t->recv_offset += err;
 324
 325                 if (t->recv_offset == attr_size) {
 326                         dnet_convert_attr(&t->cmd.attr);
 327                         dnet_convert_io_attr(&t->cmd.p.io);
 328
 329                         pohmelfs_print_addr(&recv->sa, "%s: io size: %llu\n",
 330                                 pohmelfs_dump_id(cmd->id.id), (unsigned long long)t->cmd.p.io.size);
 331                 }
 332         }
 333
 334         if (t->recv_offset == attr_size)
 335                 priv->offset = 0;
 336
 337         if (t->recv_offset >= attr_size) {
 338                 if (priv->offset < sizeof(struct pohmelfs_inode_info)) {
 339                         /* receiving pohmelfs_inode_info first */
 340                         err = pohmelfs_data_recv(recv, t->recv_data + priv->offset,
 341                                         sizeof(struct pohmelfs_inode_info) - priv->offset, MSG_DONTWAIT);
 342                         if (err < 0)
 343                                 goto err_out_exit;
 344
 345                         t->recv_offset += err;
 346                         priv->offset += err;
 347                 }
 348
 349                 if ((priv->offset == sizeof(struct pohmelfs_inode_info)) && !priv->namelen) {
 350                         struct pohmelfs_inode_info *info = t->recv_data;
 351                         pohmelfs_convert_inode_info(info);
 352                         priv->namelen = info->namelen;
 353                 }
 354
 355                 if ((priv->offset >= sizeof(struct pohmelfs_inode_info)) && priv->namelen) {
 356                         pohmelfs_lookup_recv_inode(t, recv);
 357                 }
 358
 359         }
 360
 361         return 0;
 362
 363 err_out_exit:
 364         return err;
 365 }
 366
 367 static struct pohmelfs_inode *pohmelfs_warm_dir(struct inode *dir, struct dentry *dentry)
 368 {
 369         struct pohmelfs_sb *psb = pohmelfs_sb(dir->i_sb);
 370         struct pohmelfs_inode *parent = pohmelfs_inode(dir);
 371         struct pohmelfs_inode *pi;
 372         struct pohmelfs_io io;
 373         struct pohmelfs_lookup_priv *priv;
 374         struct pohmelfs_wait *wait;
 375         long ret;
 376         int err;
 377
 378         priv = kzalloc(sizeof(struct pohmelfs_lookup_priv), GFP_NOIO);
 379         if (!priv) {
 380                 err = -ENOMEM;
 381                 goto err_out_exit;
 382         }
 383
 384         kref_init(&priv->refcnt);
 385
 386         wait = pohmelfs_wait_alloc(parent);
 387         if (!wait) {
 388                 err = -ENOMEM;
 389                 goto err_out_put;
 390         }
 391
 392         priv->wait = wait;
 393         kref_get(&priv->refcnt);
 394
 395         if (!dentry)
 396                 priv->load_all = 1;
 397         else {
 398                 pohmelfs_hash(psb, dentry->d_name.name, dentry->d_name.len, &priv->name_id);
 399         }
 400
 401         memset(&io, 0, sizeof(struct pohmelfs_io));
 402
 403         io.pi = parent;
 404         io.id = &parent->id;
 405         io.group = 2;
 406         io.aflags = DNET_ATTR_NOCSUM;
 407         io.cmd = DNET_CMD_READ;
 408         io.recv_reply = pohmelfs_lookup_recv_reply;
 409         io.complete = pohmelfs_lookup_complete;
 410         io.priv = priv;
 411
 412         err = pohmelfs_send_io(&io);
 413         if (err) {
 414                 pr_info("pohmelfs: pohmelfs_warm_dir: pohmelfs_send_io: %s, ino: %lu: %d\n",
 415                                 pohmelfs_dump_id(parent->id.id), dir->i_ino, err);
 416                 goto err_out_put;
 417         }
 418
 419         ret = wait_event_interruptible_timeout(wait->wq, wait->condition != 0, msecs_to_jiffies(psb->read_wait_timeout));
 420         if (ret <= 0) {
 421                 err = ret;
 422                 if (ret == 0)
 423                         err = -ETIMEDOUT;
 424                 goto err_out_put;
 425         }
 426
 427         err = -ENOENT;
 428         if (!priv->found)
 429                 goto err_out_put;
 430
 431         pi = pohmelfs_sb_inode_lookup(psb, &priv->inode_id);
 432         if (!pi)
 433                 goto err_out_put;
 434
 435         kref_put(&priv->refcnt, pohmelfs_lookup_free);
 436         return pi;
 437
 438 err_out_put:
 439         kref_put(&priv->refcnt, pohmelfs_lookup_free);
 440 err_out_exit:
 441         pr_info("pohmelfs: pohmelfs_warm_dir: %s, parent: %lu: %d\n",
 442                 pohmelfs_dump_id(parent->id.id), dir->i_ino, err);
 443         return ERR_PTR(err);
 444 }
 445
 446 static struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 447 {
 448         struct pohmelfs_inode *pi;
 449         struct inode *inode = NULL;
 450         struct pohmelfs_inode *parent = pohmelfs_inode(dir);
 451         int err;
 452
 453         pi = pohmelfs_warm_dir(dir, dentry);
 454         if (IS_ERR(pi)) {
 455                 err = PTR_ERR(pi);
 456                 if (err != -ENOENT)
 457                         goto err_out_exit;
 458         } else {
 459                 inode = &pi->vfs_inode;
 460
 461                 pr_info("pohmelfs: lookup: %s, parent: %lu, object: %s -> ino: %lu\n",
 462                         pohmelfs_dump_id(parent->id.id), dir->i_ino, dentry->d_name.name, pi->vfs_inode.i_ino);
 463
 464                 /* we grabbed a reference in pohmelfs_sb_inode_lookup() */
 465                 iput(inode);
 466         }
 467
 468         return d_splice_alias(inode, dentry);
 469
 470 err_out_exit:
 471         pr_err("pohmelfs: lookup failed: %s, parent: %lu, object: %s: %d\n",
 472                 pohmelfs_dump_id(parent->id.id), dir->i_ino, dentry->d_name.name, err);
 473         return ERR_PTR(err);
 474 }
 475
 476 const struct inode_operations pohmelfs_dir_inode_operations = {
 477         .create         = pohmelfs_create,
 478         .lookup         = pohmelfs_lookup,
 479 };
 480
 481 static int pohmelfs_readdir(struct file *file, void *dirent, filldir_t filldir)
 482 {
 483         struct inode *inode = file->f_path.dentry->d_inode;
 484         struct pohmelfs_inode *pi = pohmelfs_inode(inode);
 485
 486         if (!file->f_pos) {
 487                 pr_info("pohmelfs: readdir: %s: ino: %lu\n", pohmelfs_dump_id(pi->id.id), inode->i_ino);
 488                 pohmelfs_warm_dir(inode, NULL);
 489         }
 490
 491         return dcache_readdir(file, dirent, filldir);
 492 }
 493
 494 const struct file_operations pohmelfs_dir_fops = {
 495         .open           = dcache_dir_open,
 496         .release        = dcache_dir_close,
 497         .llseek         = dcache_dir_lseek,
 498
 499         .read           = generic_read_dir,
 500         .readdir        = pohmelfs_readdir,
 501 };