linux/fs/afs/internal.h
<<
>>
Prefs 
   1/* internal AFS stuff
   2 *
   3 * Copyright (C) 2002, 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 License
   8 * as published by the Free Software Foundation; either version
   9 * 2 of the License, or (at your option) any later version.
  10 */
  11
  12#include <linux/compiler.h>
  13#include <linux/kernel.h>
  14#include <linux/fs.h>
  15#include <linux/pagemap.h>
  16#include <linux/skbuff.h>
  17#include <linux/rxrpc.h>
  18#include <linux/key.h>
  19#include <linux/workqueue.h>
  20#include <linux/sched.h>
  21#include <linux/fscache.h>
  22#include <linux/backing-dev.h>
  23
  24#include "afs.h"
  25#include "afs_vl.h"
  26
  27#define AFS_CELL_MAX_ADDRS 15
  28
  29struct pagevec;
  30struct afs_call;
  31
  32typedef enum {
  33        AFS_VL_NEW,                     /* new, uninitialised record */
  34        AFS_VL_CREATING,                /* creating record */
  35        AFS_VL_VALID,                   /* record is pending */
  36        AFS_VL_NO_VOLUME,               /* no such volume available */
  37        AFS_VL_UPDATING,                /* update in progress */
  38        AFS_VL_VOLUME_DELETED,          /* volume was deleted */
  39        AFS_VL_UNCERTAIN,               /* uncertain state (update failed) */
  40} __attribute__((packed)) afs_vlocation_state_t;
  41
  42struct afs_mount_params {
  43        bool                    rwpath;         /* T if the parent should be considered R/W */
  44        bool                    force;          /* T to force cell type */
  45        afs_voltype_t           type;           /* type of volume requested */
  46        int                     volnamesz;      /* size of volume name */
  47        const char              *volname;       /* name of volume to mount */
  48        struct afs_cell         *cell;          /* cell in which to find volume */
  49        struct afs_volume       *volume;        /* volume record */
  50        struct key              *key;           /* key to use for secure mounting */
  51};
  52
  53/*
  54 * definition of how to wait for the completion of an operation
  55 */
  56struct afs_wait_mode {
  57        /* RxRPC received message notification */
  58        void (*rx_wakeup)(struct afs_call *call);
  59
  60        /* synchronous call waiter and call dispatched notification */
  61        int (*wait)(struct afs_call *call);
  62
  63        /* asynchronous call completion */
  64        void (*async_complete)(void *reply, int error);
  65};
  66
  67extern const struct afs_wait_mode afs_sync_call;
  68extern const struct afs_wait_mode afs_async_call;
  69
  70/*
  71 * a record of an in-progress RxRPC call
  72 */
  73struct afs_call {
  74        const struct afs_call_type *type;       /* type of call */
  75        const struct afs_wait_mode *wait_mode;  /* completion wait mode */
  76        wait_queue_head_t       waitq;          /* processes awaiting completion */
  77        struct work_struct      async_work;     /* asynchronous work processor */
  78        struct work_struct      work;           /* actual work processor */
  79        struct sk_buff_head     rx_queue;       /* received packets */
  80        struct rxrpc_call       *rxcall;        /* RxRPC call handle */
  81        struct key              *key;           /* security for this call */
  82        struct afs_server       *server;        /* server affected by incoming CM call */
  83        void                    *request;       /* request data (first part) */
  84        struct address_space    *mapping;       /* page set */
  85        struct afs_writeback    *wb;            /* writeback being performed */
  86        void                    *buffer;        /* reply receive buffer */
  87        void                    *reply;         /* reply buffer (first part) */
  88        void                    *reply2;        /* reply buffer (second part) */
  89        void                    *reply3;        /* reply buffer (third part) */
  90        void                    *reply4;        /* reply buffer (fourth part) */
  91        pgoff_t                 first;          /* first page in mapping to deal with */
  92        pgoff_t                 last;           /* last page in mapping to deal with */
  93        enum {                                  /* call state */
  94                AFS_CALL_REQUESTING,    /* request is being sent for outgoing call */
  95                AFS_CALL_AWAIT_REPLY,   /* awaiting reply to outgoing call */
  96                AFS_CALL_AWAIT_OP_ID,   /* awaiting op ID on incoming call */
  97                AFS_CALL_AWAIT_REQUEST, /* awaiting request data on incoming call */
  98                AFS_CALL_REPLYING,      /* replying to incoming call */
  99                AFS_CALL_AWAIT_ACK,     /* awaiting final ACK of incoming call */
 100                AFS_CALL_COMPLETE,      /* successfully completed */
 101                AFS_CALL_BUSY,          /* server was busy */
 102                AFS_CALL_ABORTED,       /* call was aborted */
 103                AFS_CALL_ERROR,         /* call failed due to error */
 104        }                       state;
 105        int                     error;          /* error code */
 106        unsigned                request_size;   /* size of request data */
 107        unsigned                reply_max;      /* maximum size of reply */
 108        unsigned                reply_size;     /* current size of reply */
 109        unsigned                first_offset;   /* offset into mapping[first] */
 110        unsigned                last_to;        /* amount of mapping[last] */
 111        unsigned short          offset;         /* offset into received data store */
 112        unsigned char           unmarshall;     /* unmarshalling phase */
 113        bool                    incoming;       /* T if incoming call */
 114        bool                    send_pages;     /* T if data from mapping should be sent */
 115        u16                     service_id;     /* RxRPC service ID to call */
 116        __be16                  port;           /* target UDP port */
 117        __be32                  operation_ID;   /* operation ID for an incoming call */
 118        u32                     count;          /* count for use in unmarshalling */
 119        __be32                  tmp;            /* place to extract temporary data */
 120        afs_dataversion_t       store_version;  /* updated version expected from store */
 121};
 122
 123struct afs_call_type {
 124        const char *name;
 125
 126        /* deliver request or reply data to an call
 127         * - returning an error will cause the call to be aborted
 128         */
 129        int (*deliver)(struct afs_call *call, struct sk_buff *skb,
 130                       bool last);
 131
 132        /* map an abort code to an error number */
 133        int (*abort_to_error)(u32 abort_code);
 134
 135        /* clean up a call */
 136        void (*destructor)(struct afs_call *call);
 137};
 138
 139/*
 140 * record of an outstanding writeback on a vnode
 141 */
 142struct afs_writeback {
 143        struct list_head        link;           /* link in vnode->writebacks */
 144        struct work_struct      writer;         /* work item to perform the writeback */
 145        struct afs_vnode        *vnode;         /* vnode to which this write applies */
 146        struct key              *key;           /* owner of this write */
 147        wait_queue_head_t       waitq;          /* completion and ready wait queue */
 148        pgoff_t                 first;          /* first page in batch */
 149        pgoff_t                 point;          /* last page in current store op */
 150        pgoff_t                 last;           /* last page in batch (inclusive) */
 151        unsigned                offset_first;   /* offset into first page of start of write */
 152        unsigned                to_last;        /* offset into last page of end of write */
 153        int                     num_conflicts;  /* count of conflicting writes in list */
 154        int                     usage;
 155        bool                    conflicts;      /* T if has dependent conflicts */
 156        enum {
 157                AFS_WBACK_SYNCING,              /* synchronisation being performed */
 158                AFS_WBACK_PENDING,              /* write pending */
 159                AFS_WBACK_CONFLICTING,          /* conflicting writes posted */
 160                AFS_WBACK_WRITING,              /* writing back */
 161                AFS_WBACK_COMPLETE              /* the writeback record has been unlinked */
 162        } state __attribute__((packed));
 163};
 164
 165/*
 166 * AFS superblock private data
 167 * - there's one superblock per volume
 168 */
 169struct afs_super_info {
 170        struct afs_volume       *volume;        /* volume record */
 171        char                    rwparent;       /* T if parent is R/W AFS volume */
 172};
 173
 174static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
 175{
 176        return sb->s_fs_info;
 177}
 178
 179extern struct file_system_type afs_fs_type;
 180
 181/*
 182 * entry in the cached cell catalogue
 183 */
 184struct afs_cache_cell {
 185        char            name[AFS_MAXCELLNAME];  /* cell name (padded with NULs) */
 186        struct in_addr  vl_servers[15];         /* cached cell VL servers */
 187};
 188
 189/*
 190 * AFS cell record
 191 */
 192struct afs_cell {
 193        atomic_t                usage;
 194        struct list_head        link;           /* main cell list link */
 195        struct key              *anonymous_key; /* anonymous user key for this cell */
 196        struct list_head        proc_link;      /* /proc cell list link */
 197        struct proc_dir_entry   *proc_dir;      /* /proc dir for this cell */
 198#ifdef CONFIG_AFS_FSCACHE
 199        struct fscache_cookie   *cache;         /* caching cookie */
 200#endif
 201
 202        /* server record management */
 203        rwlock_t                servers_lock;   /* active server list lock */
 204        struct list_head        servers;        /* active server list */
 205
 206        /* volume location record management */
 207        struct rw_semaphore     vl_sem;         /* volume management serialisation semaphore */
 208        struct list_head        vl_list;        /* cell's active VL record list */
 209        spinlock_t              vl_lock;        /* vl_list lock */
 210        unsigned short          vl_naddrs;      /* number of VL servers in addr list */
 211        unsigned short          vl_curr_svix;   /* current server index */
 212        struct in_addr          vl_addrs[AFS_CELL_MAX_ADDRS];   /* cell VL server addresses */
 213
 214        char                    name[0];        /* cell name - must go last */
 215};
 216
 217/*
 218 * entry in the cached volume location catalogue
 219 */
 220struct afs_cache_vlocation {
 221        /* volume name (lowercase, padded with NULs) */
 222        uint8_t                 name[AFS_MAXVOLNAME + 1];
 223
 224        uint8_t                 nservers;       /* number of entries used in servers[] */
 225        uint8_t                 vidmask;        /* voltype mask for vid[] */
 226        uint8_t                 srvtmask[8];    /* voltype masks for servers[] */
 227#define AFS_VOL_VTM_RW  0x01 /* R/W version of the volume is available (on this server) */
 228#define AFS_VOL_VTM_RO  0x02 /* R/O version of the volume is available (on this server) */
 229#define AFS_VOL_VTM_BAK 0x04 /* backup version of the volume is available (on this server) */
 230
 231        afs_volid_t             vid[3];         /* volume IDs for R/W, R/O and Bak volumes */
 232        struct in_addr          servers[8];     /* fileserver addresses */
 233        time_t                  rtime;          /* last retrieval time */
 234};
 235
 236/*
 237 * volume -> vnode hash table entry
 238 */
 239struct afs_cache_vhash {
 240        afs_voltype_t           vtype;          /* which volume variation */
 241        uint8_t                 hash_bucket;    /* which hash bucket this represents */
 242} __attribute__((packed));
 243
 244/*
 245 * AFS volume location record
 246 */
 247struct afs_vlocation {
 248        atomic_t                usage;
 249        time_t                  time_of_death;  /* time at which put reduced usage to 0 */
 250        struct list_head        link;           /* link in cell volume location list */
 251        struct list_head        grave;          /* link in master graveyard list */
 252        struct list_head        update;         /* link in master update list */
 253        struct afs_cell         *cell;          /* cell to which volume belongs */
 254#ifdef CONFIG_AFS_FSCACHE
 255        struct fscache_cookie   *cache;         /* caching cookie */
 256#endif
 257        struct afs_cache_vlocation vldb;        /* volume information DB record */
 258        struct afs_volume       *vols[3];       /* volume access record pointer (index by type) */
 259        wait_queue_head_t       waitq;          /* status change waitqueue */
 260        time_t                  update_at;      /* time at which record should be updated */
 261        spinlock_t              lock;           /* access lock */
 262        afs_vlocation_state_t   state;          /* volume location state */
 263        unsigned short          upd_rej_cnt;    /* ENOMEDIUM count during update */
 264        unsigned short          upd_busy_cnt;   /* EBUSY count during update */
 265        bool                    valid;          /* T if valid */
 266};
 267
 268/*
 269 * AFS fileserver record
 270 */
 271struct afs_server {
 272        atomic_t                usage;
 273        time_t                  time_of_death;  /* time at which put reduced usage to 0 */
 274        struct in_addr          addr;           /* server address */
 275        struct afs_cell         *cell;          /* cell in which server resides */
 276        struct list_head        link;           /* link in cell's server list */
 277        struct list_head        grave;          /* link in master graveyard list */
 278        struct rb_node          master_rb;      /* link in master by-addr tree */
 279        struct rw_semaphore     sem;            /* access lock */
 280
 281        /* file service access */
 282        struct rb_root          fs_vnodes;      /* vnodes backed by this server (ordered by FID) */
 283        unsigned long           fs_act_jif;     /* time at which last activity occurred */
 284        unsigned long           fs_dead_jif;    /* time at which no longer to be considered dead */
 285        spinlock_t              fs_lock;        /* access lock */
 286        int                     fs_state;       /* 0 or reason FS currently marked dead (-errno) */
 287
 288        /* callback promise management */
 289        struct rb_root          cb_promises;    /* vnode expiration list (ordered earliest first) */
 290        struct delayed_work     cb_updater;     /* callback updater */
 291        struct delayed_work     cb_break_work;  /* collected break dispatcher */
 292        wait_queue_head_t       cb_break_waitq; /* space available in cb_break waitqueue */
 293        spinlock_t              cb_lock;        /* access lock */
 294        struct afs_callback     cb_break[64];   /* ring of callbacks awaiting breaking */
 295        atomic_t                cb_break_n;     /* number of pending breaks */
 296        u8                      cb_break_head;  /* head of callback breaking ring */
 297        u8                      cb_break_tail;  /* tail of callback breaking ring */
 298};
 299
 300/*
 301 * AFS volume access record
 302 */
 303struct afs_volume {
 304        atomic_t                usage;
 305        struct afs_cell         *cell;          /* cell to which belongs (unrefd ptr) */
 306        struct afs_vlocation    *vlocation;     /* volume location */
 307#ifdef CONFIG_AFS_FSCACHE
 308        struct fscache_cookie   *cache;         /* caching cookie */
 309#endif
 310        afs_volid_t             vid;            /* volume ID */
 311        afs_voltype_t           type;           /* type of volume */
 312        char                    type_force;     /* force volume type (suppress R/O -> R/W) */
 313        unsigned short          nservers;       /* number of server slots filled */
 314        unsigned short          rjservers;      /* number of servers discarded due to -ENOMEDIUM */
 315        struct afs_server       *servers[8];    /* servers on which volume resides (ordered) */
 316        struct rw_semaphore     server_sem;     /* lock for accessing current server */
 317        struct backing_dev_info bdi;
 318};
 319
 320/*
 321 * vnode catalogue entry
 322 */
 323struct afs_cache_vnode {
 324        afs_vnodeid_t           vnode_id;       /* vnode ID */
 325        unsigned                vnode_unique;   /* vnode ID uniquifier */
 326        afs_dataversion_t       data_version;   /* data version */
 327};
 328
 329/*
 330 * AFS inode private data
 331 */
 332struct afs_vnode {
 333        struct inode            vfs_inode;      /* the VFS's inode record */
 334
 335        struct afs_volume       *volume;        /* volume on which vnode resides */
 336        struct afs_server       *server;        /* server currently supplying this file */
 337        struct afs_fid          fid;            /* the file identifier for this inode */
 338        struct afs_file_status  status;         /* AFS status info for this file */
 339#ifdef CONFIG_AFS_FSCACHE
 340        struct fscache_cookie   *cache;         /* caching cookie */
 341#endif
 342        struct afs_permits      *permits;       /* cache of permits so far obtained */
 343        struct mutex            permits_lock;   /* lock for altering permits list */
 344        struct mutex            validate_lock;  /* lock for validating this vnode */
 345        wait_queue_head_t       update_waitq;   /* status fetch waitqueue */
 346        int                     update_cnt;     /* number of outstanding ops that will update the
 347                                                 * status */
 348        spinlock_t              writeback_lock; /* lock for writebacks */
 349        spinlock_t              lock;           /* waitqueue/flags lock */
 350        unsigned long           flags;
 351#define AFS_VNODE_CB_BROKEN     0               /* set if vnode's callback was broken */
 352#define AFS_VNODE_UNSET         1               /* set if vnode attributes not yet set */
 353#define AFS_VNODE_MODIFIED      2               /* set if vnode's data modified */
 354#define AFS_VNODE_ZAP_DATA      3               /* set if vnode's data should be invalidated */
 355#define AFS_VNODE_DELETED       4               /* set if vnode deleted on server */
 356#define AFS_VNODE_MOUNTPOINT    5               /* set if vnode is a mountpoint symlink */
 357#define AFS_VNODE_LOCKING       6               /* set if waiting for lock on vnode */
 358#define AFS_VNODE_READLOCKED    7               /* set if vnode is read-locked on the server */
 359#define AFS_VNODE_WRITELOCKED   8               /* set if vnode is write-locked on the server */
 360#define AFS_VNODE_UNLOCKING     9               /* set if vnode is being unlocked on the server */
 361
 362        long                    acl_order;      /* ACL check count (callback break count) */
 363
 364        struct list_head        writebacks;     /* alterations in pagecache that need writing */
 365        struct list_head        pending_locks;  /* locks waiting to be granted */
 366        struct list_head        granted_locks;  /* locks granted on this file */
 367        struct delayed_work     lock_work;      /* work to be done in locking */
 368        struct key              *unlock_key;    /* key to be used in unlocking */
 369
 370        /* outstanding callback notification on this file */
 371        struct rb_node          server_rb;      /* link in server->fs_vnodes */
 372        struct rb_node          cb_promise;     /* link in server->cb_promises */
 373        struct work_struct      cb_broken_work; /* work to be done on callback break */
 374        time_t                  cb_expires;     /* time at which callback expires */
 375        time_t                  cb_expires_at;  /* time used to order cb_promise */
 376        unsigned                cb_version;     /* callback version */
 377        unsigned                cb_expiry;      /* callback expiry time */
 378        afs_callback_type_t     cb_type;        /* type of callback */
 379        bool                    cb_promised;    /* true if promise still holds */
 380};
 381
 382/*
 383 * cached security record for one user's attempt to access a vnode
 384 */
 385struct afs_permit {
 386        struct key              *key;           /* RxRPC ticket holding a security context */
 387        afs_access_t            access_mask;    /* access mask for this key */
 388};
 389
 390/*
 391 * cache of security records from attempts to access a vnode
 392 */
 393struct afs_permits {
 394        struct rcu_head         rcu;            /* disposal procedure */
 395        int                     count;          /* number of records */
 396        struct afs_permit       permits[0];     /* the permits so far examined */
 397};
 398
 399/*
 400 * record of one of a system's set of network interfaces
 401 */
 402struct afs_interface {
 403        struct in_addr  address;        /* IPv4 address bound to interface */
 404        struct in_addr  netmask;        /* netmask applied to address */
 405        unsigned        mtu;            /* MTU of interface */
 406};
 407
 408/*
 409 * UUID definition [internet draft]
 410 * - the timestamp is a 60-bit value, split 32/16/12, and goes in 100ns
 411 *   increments since midnight 15th October 1582
 412 *   - add AFS_UUID_TO_UNIX_TIME to convert unix time in 100ns units to UUID
 413 *     time
 414 * - the clock sequence is a 14-bit counter to avoid duplicate times
 415 */
 416struct afs_uuid {
 417        u32             time_low;                       /* low part of timestamp */
 418        u16             time_mid;                       /* mid part of timestamp */
 419        u16             time_hi_and_version;            /* high part of timestamp and version  */
 420#define AFS_UUID_TO_UNIX_TIME   0x01b21dd213814000ULL
 421#define AFS_UUID_TIMEHI_MASK    0x0fff
 422#define AFS_UUID_VERSION_TIME   0x1000  /* time-based UUID */
 423#define AFS_UUID_VERSION_NAME   0x3000  /* name-based UUID */
 424#define AFS_UUID_VERSION_RANDOM 0x4000  /* (pseudo-)random generated UUID */
 425        u8              clock_seq_hi_and_reserved;      /* clock seq hi and variant */
 426#define AFS_UUID_CLOCKHI_MASK   0x3f
 427#define AFS_UUID_VARIANT_STD    0x80
 428        u8              clock_seq_low;                  /* clock seq low */
 429        u8              node[6];                        /* spatially unique node ID (MAC addr) */
 430};
 431
 432/*****************************************************************************/
 433/*
 434 * cache.c
 435 */
 436#ifdef CONFIG_AFS_FSCACHE
 437extern struct fscache_netfs afs_cache_netfs;
 438extern struct fscache_cookie_def afs_cell_cache_index_def;
 439extern struct fscache_cookie_def afs_vlocation_cache_index_def;
 440extern struct fscache_cookie_def afs_volume_cache_index_def;
 441extern struct fscache_cookie_def afs_vnode_cache_index_def;
 442#else
 443#define afs_cell_cache_index_def        (*(struct fscache_cookie_def *) NULL)
 444#define afs_vlocation_cache_index_def   (*(struct fscache_cookie_def *) NULL)
 445#define afs_volume_cache_index_def      (*(struct fscache_cookie_def *) NULL)
 446#define afs_vnode_cache_index_def       (*(struct fscache_cookie_def *) NULL)
 447#endif
 448
 449/*
 450 * callback.c
 451 */
 452extern void afs_init_callback_state(struct afs_server *);
 453extern void afs_broken_callback_work(struct work_struct *);
 454extern void afs_break_callbacks(struct afs_server *, size_t,
 455                                struct afs_callback[]);
 456extern void afs_discard_callback_on_delete(struct afs_vnode *);
 457extern void afs_give_up_callback(struct afs_vnode *);
 458extern void afs_dispatch_give_up_callbacks(struct work_struct *);
 459extern void afs_flush_callback_breaks(struct afs_server *);
 460extern int __init afs_callback_update_init(void);
 461extern void afs_callback_update_kill(void);
 462
 463/*
 464 * cell.c
 465 */
 466extern struct rw_semaphore afs_proc_cells_sem;
 467extern struct list_head afs_proc_cells;
 468
 469#define afs_get_cell(C) do { atomic_inc(&(C)->usage); } while(0)
 470extern int afs_cell_init(char *);
 471extern struct afs_cell *afs_cell_create(const char *, char *);
 472extern struct afs_cell *afs_cell_lookup(const char *, unsigned);
 473extern struct afs_cell *afs_grab_cell(struct afs_cell *);
 474extern void afs_put_cell(struct afs_cell *);
 475extern void afs_cell_purge(void);
 476
 477/*
 478 * cmservice.c
 479 */
 480extern bool afs_cm_incoming_call(struct afs_call *);
 481
 482/*
 483 * dir.c
 484 */
 485extern const struct inode_operations afs_dir_inode_operations;
 486extern const struct file_operations afs_dir_file_operations;
 487
 488/*
 489 * file.c
 490 */
 491extern const struct address_space_operations afs_fs_aops;
 492extern const struct inode_operations afs_file_inode_operations;
 493extern const struct file_operations afs_file_operations;
 494
 495extern int afs_open(struct inode *, struct file *);
 496extern int afs_release(struct inode *, struct file *);
 497extern int afs_page_filler(void *, struct page *);
 498
 499/*
 500 * flock.c
 501 */
 502extern void __exit afs_kill_lock_manager(void);
 503extern void afs_lock_work(struct work_struct *);
 504extern void afs_lock_may_be_available(struct afs_vnode *);
 505extern int afs_lock(struct file *, int, struct file_lock *);
 506extern int afs_flock(struct file *, int, struct file_lock *);
 507
 508/*
 509 * fsclient.c
 510 */
 511extern int afs_fs_fetch_file_status(struct afs_server *, struct key *,
 512                                    struct afs_vnode *, struct afs_volsync *,
 513                                    const struct afs_wait_mode *);
 514extern int afs_fs_give_up_callbacks(struct afs_server *,
 515                                    const struct afs_wait_mode *);
 516extern int afs_fs_fetch_data(struct afs_server *, struct key *,
 517                             struct afs_vnode *, off_t, size_t, struct page *,
 518                             const struct afs_wait_mode *);
 519extern int afs_fs_create(struct afs_server *, struct key *,
 520                         struct afs_vnode *, const char *, umode_t,
 521                         struct afs_fid *, struct afs_file_status *,
 522                         struct afs_callback *,
 523                         const struct afs_wait_mode *);
 524extern int afs_fs_remove(struct afs_server *, struct key *,
 525                         struct afs_vnode *, const char *, bool,
 526                         const struct afs_wait_mode *);
 527extern int afs_fs_link(struct afs_server *, struct key *, struct afs_vnode *,
 528                       struct afs_vnode *, const char *,
 529                       const struct afs_wait_mode *);
 530extern int afs_fs_symlink(struct afs_server *, struct key *,
 531                          struct afs_vnode *, const char *, const char *,
 532                          struct afs_fid *, struct afs_file_status *,
 533                          const struct afs_wait_mode *);
 534extern int afs_fs_rename(struct afs_server *, struct key *,
 535                         struct afs_vnode *, const char *,
 536                         struct afs_vnode *, const char *,
 537                         const struct afs_wait_mode *);
 538extern int afs_fs_store_data(struct afs_server *, struct afs_writeback *,
 539                             pgoff_t, pgoff_t, unsigned, unsigned,
 540                             const struct afs_wait_mode *);
 541extern int afs_fs_setattr(struct afs_server *, struct key *,
 542                          struct afs_vnode *, struct iattr *,
 543                          const struct afs_wait_mode *);
 544extern int afs_fs_get_volume_status(struct afs_server *, struct key *,
 545                                    struct afs_vnode *,
 546                                    struct afs_volume_status *,
 547                                    const struct afs_wait_mode *);
 548extern int afs_fs_set_lock(struct afs_server *, struct key *,
 549                           struct afs_vnode *, afs_lock_type_t,
 550                           const struct afs_wait_mode *);
 551extern int afs_fs_extend_lock(struct afs_server *, struct key *,
 552                              struct afs_vnode *,
 553                              const struct afs_wait_mode *);
 554extern int afs_fs_release_lock(struct afs_server *, struct key *,
 555                               struct afs_vnode *,
 556                               const struct afs_wait_mode *);
 557
 558/*
 559 * inode.c
 560 */
 561extern struct inode *afs_iget(struct super_block *, struct key *,
 562                              struct afs_fid *, struct afs_file_status *,
 563                              struct afs_callback *);
 564extern void afs_zap_data(struct afs_vnode *);
 565extern int afs_validate(struct afs_vnode *, struct key *);
 566extern int afs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 567extern int afs_setattr(struct dentry *, struct iattr *);
 568extern void afs_clear_inode(struct inode *);
 569
 570/*
 571 * main.c
 572 */
 573extern struct afs_uuid afs_uuid;
 574
 575/*
 576 * misc.c
 577 */
 578extern int afs_abort_to_error(u32);
 579
 580/*
 581 * mntpt.c
 582 */
 583extern const struct inode_operations afs_mntpt_inode_operations;
 584extern const struct file_operations afs_mntpt_file_operations;
 585
 586extern int afs_mntpt_check_symlink(struct afs_vnode *, struct key *);
 587extern void afs_mntpt_kill_timer(void);
 588
 589/*
 590 * proc.c
 591 */
 592extern int afs_proc_init(void);
 593extern void afs_proc_cleanup(void);
 594extern int afs_proc_cell_setup(struct afs_cell *);
 595extern void afs_proc_cell_remove(struct afs_cell *);
 596
 597/*
 598 * rxrpc.c
 599 */
 600extern int afs_open_socket(void);
 601extern void afs_close_socket(void);
 602extern int afs_make_call(struct in_addr *, struct afs_call *, gfp_t,
 603                         const struct afs_wait_mode *);
 604extern struct afs_call *afs_alloc_flat_call(const struct afs_call_type *,
 605                                            size_t, size_t);
 606extern void afs_flat_call_destructor(struct afs_call *);
 607extern void afs_transfer_reply(struct afs_call *, struct sk_buff *);
 608extern void afs_send_empty_reply(struct afs_call *);
 609extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
 610extern int afs_extract_data(struct afs_call *, struct sk_buff *, bool, void *,
 611                            size_t);
 612
 613/*
 614 * security.c
 615 */
 616extern void afs_clear_permits(struct afs_vnode *);
 617extern void afs_cache_permit(struct afs_vnode *, struct key *, long);
 618extern void afs_zap_permits(struct rcu_head *);
 619extern struct key *afs_request_key(struct afs_cell *);
 620extern int afs_permission(struct inode *, int);
 621
 622/*
 623 * server.c
 624 */
 625extern spinlock_t afs_server_peer_lock;
 626
 627#define afs_get_server(S)                                       \
 628do {                                                            \
 629        _debug("GET SERVER %d", atomic_read(&(S)->usage));      \
 630        atomic_inc(&(S)->usage);                                \
 631} while(0)
 632
 633extern struct afs_server *afs_lookup_server(struct afs_cell *,
 634                                            const struct in_addr *);
 635extern struct afs_server *afs_find_server(const struct in_addr *);
 636extern void afs_put_server(struct afs_server *);
 637extern void __exit afs_purge_servers(void);
 638
 639/*
 640 * super.c
 641 */
 642extern int afs_fs_init(void);
 643extern void afs_fs_exit(void);
 644
 645/*
 646 * use-rtnetlink.c
 647 */
 648extern int afs_get_ipv4_interfaces(struct afs_interface *, size_t, bool);
 649extern int afs_get_MAC_address(u8 *, size_t);
 650
 651/*
 652 * vlclient.c
 653 */
 654extern int afs_vl_get_entry_by_name(struct in_addr *, struct key *,
 655                                    const char *, struct afs_cache_vlocation *,
 656                                    const struct afs_wait_mode *);
 657extern int afs_vl_get_entry_by_id(struct in_addr *, struct key *,
 658                                  afs_volid_t, afs_voltype_t,
 659                                  struct afs_cache_vlocation *,
 660                                  const struct afs_wait_mode *);
 661
 662/*
 663 * vlocation.c
 664 */
 665#define afs_get_vlocation(V) do { atomic_inc(&(V)->usage); } while(0)
 666
 667extern int __init afs_vlocation_update_init(void);
 668extern struct afs_vlocation *afs_vlocation_lookup(struct afs_cell *,
 669                                                  struct key *,
 670                                                  const char *, size_t);
 671extern void afs_put_vlocation(struct afs_vlocation *);
 672extern void afs_vlocation_purge(void);
 673
 674/*
 675 * vnode.c
 676 */
 677static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
 678{
 679        return container_of(inode, struct afs_vnode, vfs_inode);
 680}
 681
 682static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
 683{
 684        return &vnode->vfs_inode;
 685}
 686
 687extern void afs_vnode_finalise_status_update(struct afs_vnode *,
 688                                             struct afs_server *);
 689extern int afs_vnode_fetch_status(struct afs_vnode *, struct afs_vnode *,
 690                                  struct key *);
 691extern int afs_vnode_fetch_data(struct afs_vnode *, struct key *,
 692                                off_t, size_t, struct page *);
 693extern int afs_vnode_create(struct afs_vnode *, struct key *, const char *,
 694                            umode_t, struct afs_fid *, struct afs_file_status *,
 695                            struct afs_callback *, struct afs_server **);
 696extern int afs_vnode_remove(struct afs_vnode *, struct key *, const char *,
 697                            bool);
 698extern int afs_vnode_link(struct afs_vnode *, struct afs_vnode *, struct key *,
 699                          const char *);
 700extern int afs_vnode_symlink(struct afs_vnode *, struct key *, const char *,
 701                             const char *, struct afs_fid *,
 702                             struct afs_file_status *, struct afs_server **);
 703extern int afs_vnode_rename(struct afs_vnode *, struct afs_vnode *,
 704                            struct key *, const char *, const char *);
 705extern int afs_vnode_store_data(struct afs_writeback *, pgoff_t, pgoff_t,
 706                                unsigned, unsigned);
 707extern int afs_vnode_setattr(struct afs_vnode *, struct key *, struct iattr *);
 708extern int afs_vnode_get_volume_status(struct afs_vnode *, struct key *,
 709                                       struct afs_volume_status *);
 710extern int afs_vnode_set_lock(struct afs_vnode *, struct key *,
 711                              afs_lock_type_t);
 712extern int afs_vnode_extend_lock(struct afs_vnode *, struct key *);
 713extern int afs_vnode_release_lock(struct afs_vnode *, struct key *);
 714
 715/*
 716 * volume.c
 717 */
 718#define afs_get_volume(V) do { atomic_inc(&(V)->usage); } while(0)
 719
 720extern void afs_put_volume(struct afs_volume *);
 721extern struct afs_volume *afs_volume_lookup(struct afs_mount_params *);
 722extern struct afs_server *afs_volume_pick_fileserver(struct afs_vnode *);
 723extern int afs_volume_release_fileserver(struct afs_vnode *,
 724                                         struct afs_server *, int);
 725
 726/*
 727 * write.c
 728 */
 729extern int afs_set_page_dirty(struct page *);
 730extern void afs_put_writeback(struct afs_writeback *);
 731extern int afs_write_begin(struct file *file, struct address_space *mapping,
 732                        loff_t pos, unsigned len, unsigned flags,
 733                        struct page **pagep, void **fsdata);
 734extern int afs_write_end(struct file *file, struct address_space *mapping,
 735                        loff_t pos, unsigned len, unsigned copied,
 736                        struct page *page, void *fsdata);
 737extern int afs_writepage(struct page *, struct writeback_control *);
 738extern int afs_writepages(struct address_space *, struct writeback_control *);
 739extern void afs_pages_written_back(struct afs_vnode *, struct afs_call *);
 740extern ssize_t afs_file_write(struct kiocb *, const struct iovec *,
 741                              unsigned long, loff_t);
 742extern int afs_writeback_all(struct afs_vnode *);
 743extern int afs_fsync(struct file *, int);
 744
 745
 746/*****************************************************************************/
 747/*
 748 * debug tracing
 749 */
 750extern unsigned afs_debug;
 751
 752#define dbgprintk(FMT,...) \
 753        printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
 754
 755/* make sure we maintain the format strings, even when debugging is disabled */
 756static inline __attribute__((format(printf,1,2)))
 757void _dbprintk(const char *fmt, ...)
 758{
 759}
 760
 761#define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
 762#define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
 763#define kdebug(FMT,...) dbgprintk("    "FMT ,##__VA_ARGS__)
 764
 765
 766#if defined(__KDEBUG)
 767#define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
 768#define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
 769#define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
 770
 771#elif defined(CONFIG_AFS_DEBUG)
 772#define AFS_DEBUG_KENTER        0x01
 773#define AFS_DEBUG_KLEAVE        0x02
 774#define AFS_DEBUG_KDEBUG        0x04
 775
 776#define _enter(FMT,...)                                 \
 777do {                                                    \
 778        if (unlikely(afs_debug & AFS_DEBUG_KENTER))     \
 779                kenter(FMT,##__VA_ARGS__);              \
 780} while (0)
 781
 782#define _leave(FMT,...)                                 \
 783do {                                                    \
 784        if (unlikely(afs_debug & AFS_DEBUG_KLEAVE))     \
 785                kleave(FMT,##__VA_ARGS__);              \
 786} while (0)
 787
 788#define _debug(FMT,...)                                 \
 789do {                                                    \
 790        if (unlikely(afs_debug & AFS_DEBUG_KDEBUG))     \
 791                kdebug(FMT,##__VA_ARGS__);              \
 792} while (0)
 793
 794#else
 795#define _enter(FMT,...) _dbprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
 796#define _leave(FMT,...) _dbprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
 797#define _debug(FMT,...) _dbprintk("    "FMT ,##__VA_ARGS__)
 798#endif
 799
 800/*
 801 * debug assertion checking
 802 */
 803#if 1 // defined(__KDEBUGALL)
 804
 805#define ASSERT(X)                                               \
 806do {                                                            \
 807        if (unlikely(!(X))) {                                   \
 808                printk(KERN_ERR "\n");                          \
 809                printk(KERN_ERR "AFS: Assertion failed\n");     \
 810                BUG();                                          \
 811        }                                                       \
 812} while(0)
 813
 814#define ASSERTCMP(X, OP, Y)                                             \
 815do {                                                                    \
 816        if (unlikely(!((X) OP (Y)))) {                                  \
 817                printk(KERN_ERR "\n");                                  \
 818                printk(KERN_ERR "AFS: Assertion failed\n");             \
 819                printk(KERN_ERR "%lu " #OP " %lu is false\n",           \
 820                       (unsigned long)(X), (unsigned long)(Y));         \
 821                printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",       \
 822                       (unsigned long)(X), (unsigned long)(Y));         \
 823                BUG();                                                  \
 824        }                                                               \
 825} while(0)
 826
 827#define ASSERTRANGE(L, OP1, N, OP2, H)                                  \
 828do {                                                                    \
 829        if (unlikely(!((L) OP1 (N)) || !((N) OP2 (H)))) {               \
 830                printk(KERN_ERR "\n");                                  \
 831                printk(KERN_ERR "AFS: Assertion failed\n");             \
 832                printk(KERN_ERR "%lu "#OP1" %lu "#OP2" %lu is false\n", \
 833                       (unsigned long)(L), (unsigned long)(N),          \
 834                       (unsigned long)(H));                             \
 835                printk(KERN_ERR "0x%lx "#OP1" 0x%lx "#OP2" 0x%lx is false\n", \
 836                       (unsigned long)(L), (unsigned long)(N),          \
 837                       (unsigned long)(H));                             \
 838                BUG();                                                  \
 839        }                                                               \
 840} while(0)
 841
 842#define ASSERTIF(C, X)                                          \
 843do {                                                            \
 844        if (unlikely((C) && !(X))) {                            \
 845                printk(KERN_ERR "\n");                          \
 846                printk(KERN_ERR "AFS: Assertion failed\n");     \
 847                BUG();                                          \
 848        }                                                       \
 849} while(0)
 850
 851#define ASSERTIFCMP(C, X, OP, Y)                                        \
 852do {                                                                    \
 853        if (unlikely((C) && !((X) OP (Y)))) {                           \
 854                printk(KERN_ERR "\n");                                  \
 855                printk(KERN_ERR "AFS: Assertion failed\n");             \
 856                printk(KERN_ERR "%lu " #OP " %lu is false\n",           \
 857                       (unsigned long)(X), (unsigned long)(Y));         \
 858                printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",       \
 859                       (unsigned long)(X), (unsigned long)(Y));         \
 860                BUG();                                                  \
 861        }                                                               \
 862} while(0)
 863
 864#else
 865
 866#define ASSERT(X)                               \
 867do {                                            \
 868} while(0)
 869
 870#define ASSERTCMP(X, OP, Y)                     \
 871do {                                            \
 872} while(0)
 873
 874#define ASSERTRANGE(L, OP1, N, OP2, H)          \
 875do {                                            \
 876} while(0)
 877
 878#define ASSERTIF(C, X)                          \
 879do {                                            \
 880} while(0)
 881
 882#define ASSERTIFCMP(C, X, OP, Y)                \
 883do {                                            \
 884} while(0)
 885
 886#endif /* __KDEBUGALL */
 887
The original LXR software by the LXR community, this experimental version by lxr@linux.no.
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.