*/
#define EXPORT_SYMTAB
-
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/string.h>
-#include <linux/stat.h>
-#include <linux/errno.h>
-#include <linux/locks.h>
-#include <linux/unistd.h>
-
-#include <asm/system.h>
-#include <asm/uaccess.h>
-
-#include <linux/fs.h>
-#include <linux/stat.h>
-#include <asm/uaccess.h>
-#include <asm/segment.h>
-#include <linux/miscdevice.h>
-
#define DEBUG_SUBSYSTEM S_OSC
-#include <linux/obd_class.h>
-#include <linux/lustre_lib.h>
-#include <linux/lustre_net.h>
+#include <linux/module.h>
+#include <linux/lustre_dlm.h>
#include <linux/obd_ost.h>
static void osc_con2cl(struct obd_conn *conn, struct ptlrpc_client **cl,
- struct lustre_peer **peer)
+ struct ptlrpc_connection **connection)
{
struct osc_obd *osc = &conn->oc_dev->u.osc;
*cl = osc->osc_client;
- *peer = &osc->osc_peer;
+ *connection = osc->osc_conn;
}
static int osc_connect(struct obd_conn *conn)
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_CONNECT, 0, NULL, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_CONNECT, 0, NULL, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_DISCONNECT, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_DISCONNECT, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
GOTO(out, rc);
out:
ptlrpc_free_req(request);
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_GETATTR, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_GETATTR, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_OPEN, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_OPEN, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_CLOSE, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_CLOSE, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_SETATTR, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_SETATTR, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
GOTO(out, rc);
out:
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
CERROR("oa NULL\n");
RETURN(-EINVAL);
}
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_CREATE, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_CREATE, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
CERROR("oa NULL\n");
RETURN(-EINVAL);
}
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_PUNCH, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_PUNCH, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
{
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ost_body *body;
int rc, size = sizeof(*body);
ENTRY;
CERROR("oa NULL\n");
RETURN(-EINVAL);
}
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_DESTROY, 1, &size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_DESTROY, 1, &size, NULL);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
struct niobuf *dst, struct niobuf *src)
{
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
- osc_con2cl(conn, &cl, &peer);
+ osc_con2cl(conn, &cl, &connection);
if (cl->cli_obd) {
/* local sendpage */
struct ptlrpc_bulk_desc *bulk;
int rc;
- bulk = ptlrpc_prep_bulk(peer);
+ bulk = ptlrpc_prep_bulk(connection);
if (bulk == NULL)
- return -ENOMEM;
+ RETURN(-ENOMEM);
bulk->b_buf = (void *)(unsigned long)src->addr;
bulk->b_buflen = src->len;
rc = ptlrpc_send_bulk(bulk, OSC_BULK_PORTAL);
if (rc != 0) {
CERROR("send_bulk failed: %d\n", rc);
+ ptlrpc_free_bulk(bulk);
LBUG();
- return rc;
+ RETURN(rc);
}
wait_event_interruptible(bulk->b_waitq,
ptlrpc_check_bulk_sent(bulk));
- if (bulk->b_flags == PTL_RPC_INTR) {
- EXIT;
- /* FIXME: hey hey, we leak here. */
- return -EINTR;
+ if (bulk->b_flags & PTL_RPC_FL_INTR) {
+ ptlrpc_free_bulk(bulk);
+ RETURN(-EINTR);
}
- OBD_FREE(bulk, sizeof(*bulk));
+ ptlrpc_free_bulk(bulk);
}
return 0;
obd_off *offset, obd_flag *flags)
{
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ptlrpc_request *request;
struct ost_body *body;
struct obd_ioobj ioo;
if (bulk == NULL)
RETURN(-ENOMEM);
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_BRW, 3, size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_BRW, 3, size, NULL);
if (!request)
GOTO(out, rc = -ENOMEM);
for (pages = 0, i = 0; i < num_oa; i++) {
ost_pack_ioo(&ptr1, oa[i], oa_bufs[i]);
for (j = 0; j < oa_bufs[i]; j++, pages++) {
- bulk[pages] = ptlrpc_prep_bulk(peer);
+ bulk[pages] = ptlrpc_prep_bulk(connection);
if (bulk[pages] == NULL)
GOTO(out, rc = -ENOMEM);
- spin_lock(&cl->cli_lock);
- bulk[pages]->b_xid = cl->cli_xid++;
- spin_unlock(&cl->cli_lock);
+ spin_lock(&connection->c_lock);
+ bulk[pages]->b_xid = ++connection->c_xid_out;
+ spin_unlock(&connection->c_lock);
bulk[pages]->b_buf = kmap(buf[pages]);
bulk[pages]->b_buflen = PAGE_SIZE;
}
request->rq_replen = lustre_msg_size(1, size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
GOTO(out, rc);
out:
if (bulk[pages] == NULL)
continue;
kunmap(buf[pages]);
- OBD_FREE(bulk[pages], sizeof(**bulk));
+ ptlrpc_free_bulk(bulk[pages]);
}
}
obd_off *offset, obd_flag *flags)
{
struct ptlrpc_client *cl;
- struct lustre_peer *peer;
+ struct ptlrpc_connection *connection;
struct ptlrpc_request *request;
struct obd_ioobj ioo;
struct ost_body *body;
if (!src)
RETURN(-ENOMEM);
- osc_con2cl(conn, &cl, &peer);
- request = ptlrpc_prep_req(cl, peer, OST_BRW, 3, size, NULL);
+ osc_con2cl(conn, &cl, &connection);
+ request = ptlrpc_prep_req(cl, connection, OST_BRW, 3, size, NULL);
if (!request)
RETURN(-ENOMEM);
body = lustre_msg_buf(request->rq_reqmsg, 0);
size[1] = pages * sizeof(struct niobuf);
request->rq_replen = lustre_msg_size(2, size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out, rc);
offset, flags);
}
-/* mount the file system (secretly) */
-static int osc_setup(struct obd_device *obddev, obd_count len,
- void *buf)
-
+static int osc_setup(struct obd_device *obddev, obd_count len, void *buf)
{
struct osc_obd *osc = &obddev->u.osc;
- struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
int rc;
- int dev = data->ioc_dev;
ENTRY;
+ osc->osc_conn = ptlrpc_uuid_to_connection("ost");
+ if (!osc->osc_conn)
+ RETURN(-EINVAL);
+
OBD_ALLOC(osc->osc_client, sizeof(*osc->osc_client));
if (osc->osc_client == NULL)
- RETURN(-ENOMEM);
+ GOTO(out_conn, rc = -ENOMEM);
+
+ OBD_ALLOC(osc->osc_ldlm_client, sizeof(*osc->osc_ldlm_client));
+ if (osc->osc_ldlm_client == NULL)
+ GOTO(out_client, rc = -ENOMEM);
- ptlrpc_init_client(dev, OST_REQUEST_PORTAL, OSC_REPLY_PORTAL,
- osc->osc_client);
- rc = ptlrpc_connect_client("ost", osc->osc_client, &osc->osc_peer);
+ ptlrpc_init_client(NULL, NULL, OST_REQUEST_PORTAL, OSC_REPLY_PORTAL,
+ osc->osc_client);
+ ptlrpc_init_client(NULL, NULL, LDLM_REQUEST_PORTAL, LDLM_REPLY_PORTAL,
+ osc->osc_ldlm_client);
- if (rc == 0)
- MOD_INC_USE_COUNT;
- RETURN(rc);
+ MOD_INC_USE_COUNT;
+ RETURN(0);
+
+ out_client:
+ OBD_FREE(osc->osc_client, sizeof(*osc->osc_client));
+ out_conn:
+ ptlrpc_put_connection(osc->osc_conn);
+ return rc;
}
static int osc_cleanup(struct obd_device * obddev)
{
struct osc_obd *osc = &obddev->u.osc;
- if (osc->osc_client != NULL)
- OBD_FREE(osc->osc_client, sizeof(*osc->osc_client));
+ ptlrpc_cleanup_client(osc->osc_client);
+ OBD_FREE(osc->osc_client, sizeof(*osc->osc_client));
+ ptlrpc_cleanup_client(osc->osc_ldlm_client);
+ OBD_FREE(osc->osc_ldlm_client, sizeof(*osc->osc_ldlm_client));
+ ptlrpc_put_connection(osc->osc_conn);
MOD_DEC_USE_COUNT;
return 0;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff