libsysio/include/inode.h

   1 /*
   2  *    This Cplant(TM) source code is the property of Sandia National
   3  *    Laboratories.
   4  *
   5  *    This Cplant(TM) source code is copyrighted by Sandia National
   6  *    Laboratories.
   7  *
   8  *    The redistribution of this Cplant(TM) source code is subject to the
   9  *    terms of the GNU Lesser General Public License
  10  *    (see cit/LGPL or http://www.gnu.org/licenses/lgpl.html)
  11  *
  12  *    Cplant(TM) Copyright 1998-2006 Sandia Corporation.
  13  *    Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
  14  *    license for use of this work by or on behalf of the US Government.
  15  *    Export of this program may require a license from the United States
  16  *    Government.
  17  */
  18
  19 /*
  20  * This library is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU Lesser General Public
  22  * License as published by the Free Software Foundation; either
  23  * version 2.1 of the License, or (at your option) any later version.
  24  *
  25  * This library is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  28  * Lesser General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU Lesser General Public
  31  * License along with this library; if not, write to the Free Software
  32  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  33  *
  34  * Questions or comments about this library should be sent to:
  35  *
  36  * Lee Ward
  37  * Sandia National Laboratories, New Mexico
  38  * P.O. Box 5800
  39  * Albuquerque, NM 87185-1110
  40  *
  41  * lee@sandia.gov
  42  */
  43
  44 #if defined(AUTOMOUNT_FILE_NAME) && !defined(MAX_MOUNT_DEPTH)
  45 /*
  46  * Maximum number of automounts to attempt in path traversal.
  47  */
  48 #define MAX_MOUNT_DEPTH         64
  49 #endif
  50
  51 /*
  52  * Each i-node is uniquely identified by a file identifier, supplied by
  53  * the relevant file system driver. The i-node number returned in the getattrs
  54  * call is not always enough.
  55  */
  56 struct file_identifier {
  57     void    *fid_data;
  58     size_t  fid_len;
  59 };
  60
  61 struct pnode;
  62 struct inode;
  63 struct intent;
  64 struct intnl_dirent;
  65 struct intnl_stat;
  66 #ifdef _HAVE_STATVFS
  67 struct intnl_statvfs;
  68 #endif
  69 struct io_arguments;
  70 struct ioctx;
  71
  72 /*
  73  * Operations on i-nodes.
  74  *
  75  * Should this be split up into file and name space operations?
  76  */
  77 struct inode_ops {
  78     int (*inop_lookup)(struct pnode *pno,
  79                        struct inode **inop,
  80                        struct intent *intnt,
  81                        const char *path);
  82     int (*inop_getattr)(struct pnode *pno,
  83                         struct inode *ino,
  84                         struct intnl_stat *stbuf);
  85     int (*inop_setattr)(struct pnode *pno,
  86                         struct inode *ino,
  87                         unsigned mask,
  88                         struct intnl_stat *stbuf);
  89     ssize_t (*inop_filldirentries)(struct inode *ino,
  90                                    _SYSIO_OFF_T *posp,
  91                                    char *buf,
  92                                    size_t nbytes);
  93     int (*inop_mkdir)(struct pnode *pno, mode_t mode);
  94     int (*inop_rmdir)(struct pnode *pno);
  95     int (*inop_symlink)(struct pnode *pno, const char *data);
  96     int (*inop_readlink)(struct pnode *pno, char *buf, size_t bufsiz);
  97     int (*inop_open)(struct pnode *pno, int flags, mode_t mode);
  98     int (*inop_close)(struct inode *ino);
  99     int (*inop_link)(struct pnode *old, struct pnode *new);
 100     int (*inop_unlink)(struct pnode *pno);
 101     int (*inop_rename)(struct pnode *old, struct pnode *new);
 102     int (*inop_read)(struct inode *ino, struct ioctx *ioctx);
 103     int (*inop_write)(struct inode *ino, struct ioctx *ioctx);
 104     _SYSIO_OFF_T (*inop_pos)(struct inode *ino, _SYSIO_OFF_T off);
 105     int (*inop_iodone)(struct ioctx *iocp);
 106     int (*inop_fcntl)(struct inode *ino, int cmd, va_list ap, int *rtn);
 107     int (*inop_sync)(struct inode *ino);
 108     int (*inop_datasync)(struct inode *ino);
 109     int (*inop_ioctl)(struct inode *ino, unsigned long int request, va_list ap);
 110     int (*inop_mknod)(struct pnode *pno, mode_t mode, dev_t dev);
 111 #ifdef _HAVE_STATVFS
 112     int (*inop_statvfs)(struct pnode *pno,
 113                         struct inode *ino,
 114                         struct intnl_statvfs *buf);
 115 #endif
 116     void    (*inop_gone)(struct inode *ino);
 117 };
 118
 119 /*
 120  * Values for the mask to inop_setattr.
 121  */
 122 #define SETATTR_MODE        0x01
 123 #define SETATTR_MTIME       0x02
 124 #define SETATTR_ATIME       0x04
 125 #define SETATTR_UID         0x08
 126 #define SETATTR_GID         0x10
 127 #define SETATTR_LEN         0x20
 128
 129 /*
 130  * An i-node record is maintained for each file object in the system.
 131  */
 132 struct inode {
 133     LIST_ENTRY(inode) i_link;                           /* FS i-nodes link */
 134     unsigned
 135         i_immune                        : 1,            /* immune from GC */
 136         i_zombie                        : 1;            /* stale inode */
 137     unsigned i_ref;                                     /* soft ref counter */
 138     struct inode_ops i_ops;                             /* operations */
 139     struct intnl_stat i_stbuf;                          /* attrs */
 140     struct filesys *i_fs;                               /* file system ptr */
 141     struct file_identifier *i_fid;                      /* file ident */
 142     void    *i_private;                                 /* driver data */
 143     TAILQ_ENTRY(inode) i_nodes;                         /* all i-nodes link */
 144 };
 145
 146 /*
 147  * Init an i-node record.
 148  */
 149 #define I_INIT(ino, fs, stat, ops, fid, immunity, private) \
 150     do { \
 151         (ino)->i_immune = (immunity) ? 1 : 0; \
 152         (ino)->i_zombie = 0; \
 153         (ino)->i_ref = 0; \
 154         (ino)->i_ops = *(ops); \
 155         (ino)->i_stbuf = *(stat); \
 156         (ino)->i_fs = (fs); \
 157         (ino)->i_fid = (fid); \
 158         (ino)->i_private = (private); \
 159     } while (0)
 160
 161 /*
 162  * Take soft reference to i-node.
 163  */
 164 #define I_REF(ino) \
 165     do { \
 166         TAILQ_REMOVE(&_sysio_inodes, (ino), i_nodes); \
 167         TAILQ_INSERT_TAIL(&_sysio_inodes, (ino), i_nodes); \
 168         (ino)->i_ref++; \
 169         assert((ino)->i_ref); \
 170     } while (0)
 171
 172 /*
 173  * Release soft reference to i-node.
 174  */
 175 #define I_RELE(ino) \
 176     do { \
 177         assert((ino)->i_ref); \
 178         if (!--(ino)->i_ref && (ino)->i_zombie) \
 179                 _sysio_i_gone(ino); \
 180     } while (0)
 181
 182 /*
 183  * Attempt to kill an inode.
 184  */
 185 #define I_GONE(ino) \
 186     do { \
 187         _sysio_i_undead(ino); \
 188         I_RELE(ino); \
 189     } while (0)
 190
 191 /*
 192  * The "quick string" record (inspired by the structure of the same name
 193  * from Linux) is used to pass a string without delimiters as well as useful
 194  * information about the string.
 195  */
 196 struct qstr {
 197     const char *name;
 198     size_t  len;
 199     unsigned hashval;
 200 };
 201
 202 /*
 203  * A path node is an entry in a directory. It may have many aliases, one
 204  * for each name space in which it occurs. This record holds the
 205  * common information.
 206  */
 207 struct pnode_base {
 208     struct qstr pb_name;                                /* entry name */
 209     struct inode *pb_ino;                               /* inode */
 210     LIST_HEAD(, pnode_base) pb_children;                /* children if a dir */
 211     LIST_ENTRY(pnode_base) pb_sibs;                     /* links to siblings */
 212     LIST_ENTRY(pnode_base) pb_names;                    /* near names links */
 213     LIST_HEAD(, pnode) pb_aliases;                      /* aliases */
 214     struct pnode_base *pb_parent;                       /* parent */
 215 };
 216
 217 /*
 218  * Since a file system may be multiply mounted, in different parts of the local
 219  * tree, a file system object may appear in different places. We handle that
 220  * with aliases. There is one pnode for every alias the system is tracking.
 221  *
 222  * Name space traversal depends heavily on the interpretation of many
 223  * of the fields in this structure. For that reason a detailed discussion
 224  * of the various fields is given.
 225  *
 226  * The reference field records soft references to the record. For instance,
 227  * it tracks file and directory opens. It does not track sibling references,
 228  * though, as those are hard references and can be found by examining the
 229  * aliases list in the base part of the node.
 230  *
 231  * The parent value points to the parent directory for this entry, in the
 232  * *system* name space -- Not the mounted volumes. If you want to examine
 233  * the moutned volume name space, use the base record.
 234  *
 235  * The base value points to the base path node information. It is info common
 236  * to all of the aliases.
 237  *
 238  * The mount value points to the mount record for the rooted name space in
 239  * which the alias is found. Notably, if a node is the root of a sub-tree then
 240  * the mount record, among other things, indicates another node
 241  * (in another sub-tree) that is covered by this one.
 242  *
 243  * Another sub-tree, mounted on this node, is indicated by a non-null cover.
 244  * The pnode pointed to, then, is the root of the mounted sub-tree.
 245  *
 246  * The links list entry holds pointers to other aliases for the base path
 247  * node entry.
 248  *
 249  * The nodes link is bookkeeping.
 250  */
 251 struct pnode {
 252     unsigned p_ref;                                     /* soft ref count */
 253     struct pnode *p_parent;                             /* parent */
 254     struct pnode_base *p_base;                          /* base part */
 255     struct mount *p_mount;                              /* mount info */
 256     struct pnode *p_cover;                              /* covering pnode */
 257     LIST_ENTRY(pnode) p_links;                          /* other aliases */
 258     TAILQ_ENTRY(pnode) p_nodes;                         /* all nodes links */
 259 };
 260
 261 /*
 262  * Reference path-tree node.
 263  */
 264 #define P_REF(pno) \
 265     do { \
 266         TAILQ_REMOVE(&_sysio_pnodes, (pno), p_nodes); \
 267         TAILQ_INSERT_TAIL(&_sysio_pnodes, (pno), p_nodes); \
 268         (pno)->p_ref++; \
 269         assert((pno)->p_ref); \
 270     } while (0)
 271
 272 /*
 273  * Release reference to path-tree node.
 274  */
 275 #define P_RELE(pno) \
 276     do { \
 277         assert((pno)->p_ref); \
 278         --(pno)->p_ref; \
 279     } while (0)
 280
 281 /*
 282  * An intent record allows callers of namei and lookup to pass some information
 283  * about what they want to accomplish in the end.
 284  */
 285 struct intent {
 286     unsigned int_opmask;
 287     void    *int_arg1;
 288     void    *int_arg2;
 289 };
 290
 291 /*
 292  * Intent operations.
 293  */
 294 #define INT_GETATTR         0x01                        /* get attrs */
 295 #define INT_SETATTR         0x02                        /* set attrs */
 296 #define INT_UPDPARENT       0x04                        /* insert/delete */
 297 #define INT_OPEN            0x08                        /* open */
 298 #define INT_CREAT           (INT_UPDPARENT|0x10)        /* insert */
 299 #define INT_READLINK        0x12                        /* readlink */
 300
 301 #define INTENT_INIT(intnt, mask, arg1, arg2) \
 302     do { \
 303         (intnt)->int_opmask = (mask); \
 304         (intnt)->int_arg1 = (arg1); \
 305         (intnt)->int_arg2 = (arg2); \
 306     } while (0)
 307
 308 /*
 309  * Bundled up arguments to _sysio_path_walk.
 310  */
 311 struct nameidata {
 312     unsigned nd_flags;                                  /* flags (see below) */
 313     const char *nd_path;                                /* path arg */
 314     struct pnode *nd_pno;                               /* returned pnode */
 315     struct pnode *nd_root;                              /* system/user root */
 316     struct intent *nd_intent;                           /* intent (NULL ok) */
 317     unsigned nd_slicnt;                                 /* symlink indirects */
 318 #ifdef AUTOMOUNT_FILE_NAME
 319     unsigned nd_amcnt;                                  /* automounts */
 320 #endif
 321 };
 322
 323 /*
 324  * Values for nameidata flags field.
 325  */
 326 #define ND_NOFOLLOW     0x01                            /* no follow symlinks */
 327 #define ND_NEGOK        0x02                            /* last missing is ok */
 328 #define ND_NOPERMCHECK  0x04                            /* don't check perms */
 329
 330 #ifdef AUTOMOUNT_FILE_NAME
 331 #define _ND_INIT_AUTOMOUNT(nd)  ((nd)->nd_amcnt = 0)
 332 #else
 333 #define _ND_INIT_AUTOMOUNT(nd)
 334 #endif
 335
 336 #define _ND_INIT_OTHERS(nd) \
 337     _ND_INIT_AUTOMOUNT(nd)
 338
 339 /*
 340  * Init nameidata record.
 341  */
 342 #define ND_INIT(nd, flags, path, root, intnt) \
 343     do { \
 344         (nd)->nd_flags = (flags); \
 345         (nd)->nd_path = (path); \
 346         (nd)->nd_pno = NULL; \
 347         (nd)->nd_root = (root); \
 348         (nd)->nd_intent = (intnt); \
 349         (nd)->nd_slicnt = 0; \
 350         _ND_INIT_OTHERS(nd); \
 351     } while (0)
 352
 353 /*
 354  * IO completion callback record.
 355  */
 356 struct ioctx_callback {
 357     TAILQ_ENTRY(ioctx_callback) iocb_next;             /* list link */
 358     void    (*iocb_f)(struct ioctx *, void *);         /* cb func */
 359     void    *iocb_data;                                /* cb data */
 360 };
 361
 362 /*
 363  * All IO internally is done with an asynchronous mechanism. This record
 364  * holds the completion information. It's too big :-(
 365  */
 366 struct ioctx {
 367     LIST_ENTRY(ioctx) ioctx_link;                       /* AIO list link */
 368     unsigned
 369         ioctx_fast                      : 1,            /* from stack space */
 370         ioctx_done                      : 1,            /* transfer complete */
 371         ioctx_write                     : 1;            /* op is a write */
 372     struct inode *ioctx_ino;                            /* i-node */
 373     const struct iovec *ioctx_iov;                      /* scatter/gather vec */
 374     size_t  ioctx_iovlen;                               /* iovec length */
 375     const struct intnl_xtvec *ioctx_xtv;                /* extents */
 376     size_t  ioctx_xtvlen;                               /* xtv length */
 377     ssize_t ioctx_cc;                                   /* rtn char count */
 378     int ioctx_errno;                                    /* error number */
 379     TAILQ_HEAD(, ioctx_callback) ioctx_cbq;             /* callback queue */
 380     void *ioctx_private;                                /* driver data */
 381 };
 382
 383 /*
 384  * Init IO context record.
 385  */
 386 #define IOCTX_INIT(ioctx, fast, wr, ino, iov, iovlen, xtv, xtvlen) \
 387     do { \
 388         (ioctx)->ioctx_fast = (fast); \
 389         (ioctx)->ioctx_done = 0; \
 390         (ioctx)->ioctx_write = (wr) ? 1 : 0; \
 391         (ioctx)->ioctx_ino = (ino); \
 392         (ioctx)->ioctx_iov = (iov); \
 393         (ioctx)->ioctx_iovlen = (iovlen); \
 394         (ioctx)->ioctx_xtv = (xtv); \
 395         (ioctx)->ioctx_xtvlen = (xtvlen); \
 396         (ioctx)->ioctx_cc = 0; \
 397         (ioctx)->ioctx_errno = 0; \
 398         TAILQ_INIT(&(ioctx)->ioctx_cbq); \
 399         (ioctx)->ioctx_private = NULL; \
 400     } while (0)
 401
 402 /*
 403  * Return whether access to a pnode is read-only.
 404  */
 405 #define IS_RDONLY(pno) \
 406         ((pno)->p_mount->mnt_flags & MOUNT_F_RO)
 407
 408 extern struct pnode *_sysio_root;
 409
 410 extern TAILQ_HEAD(inodes_head, inode) _sysio_inodes;
 411 extern TAILQ_HEAD(pnodes_head, pnode) _sysio_pnodes;
 412
 413 extern int _sysio_i_init(void);
 414 #ifdef ZERO_SUM_MEMORY
 415 extern void _sysio_i_shutdown(void);
 416 #endif
 417 extern struct inode *_sysio_i_new(struct filesys *fs,
 418                                   struct file_identifier *fid,
 419                                   struct intnl_stat *stat,
 420                                   unsigned immunity,
 421                                   struct inode_ops *ops,
 422                                   void *private);
 423 extern struct inode *_sysio_i_find(struct filesys *fs,
 424                                    struct file_identifier *fid);
 425 extern void _sysio_i_gone(struct inode *ino);
 426 extern void _sysio_i_undead(struct inode *ino);
 427 extern int _sysio_p_find_alias(struct pnode *parent,
 428                                struct qstr *name,
 429                                struct pnode **pnop);
 430 extern int _sysio_p_validate(struct pnode *pno,
 431                              struct intent *intnt,
 432                              const char *path);
 433 extern struct pnode_base *_sysio_pb_new(struct qstr *name,
 434                                         struct pnode_base *parent,
 435                                         struct inode *ino);
 436 extern void _sysio_pb_gone(struct pnode_base *pb);
 437 extern struct pnode *_sysio_p_new_alias(struct pnode *parent,
 438                                         struct pnode_base *pb,
 439                                         struct mount *mnt);
 440 extern void _sysio_p_gone(struct pnode *pno);
 441 extern size_t _sysio_p_prune(struct pnode *root);
 442 extern int _sysio_p_kill_all(struct pnode *root);
 443 extern char *_sysio_pb_path(struct pnode_base *pb, char separator);
 444 extern int _sysio_setattr(struct pnode *pno,
 445                           struct inode *ino,
 446                           unsigned mask,
 447                           struct intnl_stat *stbuf);
 448 extern void _sysio_do_noop(void);
 449 extern void _sysio_do_illop(void);
 450 extern int _sysio_do_ebadf(void);
 451 extern int _sysio_do_einval(void);
 452 extern int _sysio_do_enoent(void);
 453 extern int _sysio_do_enodev(void);
 454 extern int _sysio_do_espipe(void);
 455 extern int _sysio_do_eisdir(void);
 456 extern int _sysio_do_enosys(void);
 457 extern int _sysio_path_walk(struct pnode *parent, struct nameidata *nd);
 458 #ifdef AUTOMOUNT_FILE_NAME
 459 extern void _sysio_next_component(const char *path, struct qstr *name);
 460 #endif
 461 extern int _sysio_permitted(struct pnode *pno, int amode);
 462 extern int _sysio_namei(struct pnode *pno,
 463                         const char *path,
 464                         unsigned flags,
 465                         struct intent *intnt,
 466                         struct pnode **pnop);
 467 extern int _sysio_p_chdir(struct pnode *pno);
 468 extern int _sysio_ioctx_init(void);
 469 extern void _sysio_ioctx_enter(struct ioctx *ioctx);
 470 extern struct ioctx *_sysio_ioctx_new(struct inode *ino,
 471                                       int wr,
 472                                       const struct iovec *iov,
 473                                       size_t iovlen,
 474                                       const struct intnl_xtvec *xtv,
 475                                       size_t xtvlen);
 476 extern int _sysio_ioctx_cb(struct ioctx *ioctx,
 477                            void (*f)(struct ioctx *, void *),
 478                            void *data);
 479 extern void _sysio_ioctx_cb_free(struct ioctx_callback *cb);
 480 extern struct ioctx *_sysio_ioctx_find(void *id);
 481 extern int _sysio_ioctx_done(struct ioctx *ioctx);
 482 extern ssize_t _sysio_ioctx_wait(struct ioctx *ioctx);
 483 extern void _sysio_ioctx_complete(struct ioctx *ioctx);
 484 extern int _sysio_open(struct pnode *pno, int flags, mode_t mode);
 485 extern int _sysio_mkdir(struct pnode *where, mode_t mode);
 486 extern int _sysio_mknod(struct pnode *where, mode_t mode, dev_t dev);