blob: b9dc775dc9f46bb0dc405fab2c3a28497e65d36d [file] [log] [blame]
* include/vservices/session.h
* Copyright (c) 2012-2018 General Dynamics
* Copyright (c) 2014 Open Kernel Labs, Inc.
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
* This file defines the device type for a vServices session attached to a
* transport. This should only be used by transport drivers, the vServices
* session code, and the inline transport-access functions defined in
* vservices/service.h.
* Drivers for these devices are defined internally by the vServices
* framework. Other drivers should not attach to these devices.
#include <linux/types.h>
#include <linux/device.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/idr.h>
#include <vservices/types.h>
struct vs_service_device;
struct vs_mbuf;
struct notifier_block;
* enum vs_notify_event_t - vService notifier events
* @VS_SESSION_NOTIFY_ADD: vService session added. Argument is a pointer to
* the vs_session_device. This notification is sent after the session has been
* added.
* @VS_SESSION_NOTIFY_REMOVE: vService session about to be removed. Argument is
* a pointer to the vs_session_device. This notification is sent before the
* session is removed.
enum vs_notify_event_t {
* struct vs_session_device - Session device
* @name: The unique human-readable name of this session.
* @is_server: True if this session is a server, false if client
* @transport: The transport device for this session
* @session_num: Unique ID for this session. Used for sysfs
* @session_lock: Mutex which protects any change to service presence or
* readiness
* @core_service: The core service, if one has ever been registered. Once set,
* this must remain valid and unchanged until the session driver is
* removed. Writes are protected by the service_ids_lock.
* @services: Dynamic array of the services on this session. Protected by
* service_ids_lock.
* @alloc_service_ids: Size of the session services array
* @service_ids_lock: Mutex protecting service array updates
* @activation_work: work structure for handling session activation & reset
* @activation_state: true if transport is currently active
* @fatal_error_work: work structure for handling fatal session failures
* @debug_mask: Debug level mask
* @list: Entry in the global session list
* @sysfs_entry: Kobject pointer pointing to session device in sysfs under
* sys/vservices
* @dev: Device structure for the Linux device model
struct vs_session_device {
char *name;
bool is_server;
struct vs_transport *transport;
int session_num;
struct mutex session_lock;
* The service_idr maintains the list of currently allocated services
* on a session, and allows for recycling of service ids. The lock also
* protects core_service.
struct idr service_idr;
struct mutex service_idr_lock;
struct vs_service_device *core_service;
struct work_struct activation_work;
atomic_t activation_state;
struct work_struct fatal_error_work;
unsigned long debug_mask;
struct list_head list;
struct kobject *sysfs_entry;
struct device dev;
#define to_vs_session_device(d) \
container_of(d, struct vs_session_device, dev)
extern struct vs_session_device *
vs_session_register(struct vs_transport *transport, struct device *parent,
bool server, const char *transport_name);
extern void vs_session_start(struct vs_session_device *session);
extern void vs_session_unregister(struct vs_session_device *session);
extern int vs_session_handle_message(struct vs_session_device *session,
struct vs_mbuf *mbuf, vs_service_id_t service_id);
extern void vs_session_quota_available(struct vs_session_device *session,
vs_service_id_t service_id, unsigned count,
bool send_tx_ready);
extern void vs_session_handle_notify(struct vs_session_device *session,
unsigned long flags, vs_service_id_t service_id);
extern void vs_session_handle_reset(struct vs_session_device *session);
extern void vs_session_handle_activate(struct vs_session_device *session);
extern struct vs_service_device *
vs_server_create_service(struct vs_session_device *session,
struct vs_service_device *parent, const char *name,
const char *protocol, const void *plat_data);
extern int vs_server_destroy_service(struct vs_service_device *service,
struct vs_service_device *parent);
extern void vs_session_register_notify(struct notifier_block *nb);
extern void vs_session_unregister_notify(struct notifier_block *nb);
extern int vs_session_unbind_driver(struct vs_service_device *service);
extern void vs_session_for_each_service(struct vs_session_device *session,
void (*func)(struct vs_service_device *, void *), void *data);
extern struct mutex vs_session_lock;
extern int vs_session_for_each_locked(
int (*fn)(struct vs_session_device *session, void *data),
void *data);
static inline int vs_session_for_each(
int (*fn)(struct vs_session_device *session, void *data),
void *data)
int r;
r = vs_session_for_each_locked(fn, data);
return r;
#endif /* _VSERVICES_SESSION_H_ */