mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-25 05:34:00 +08:00
1da177e4c3
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
838 lines
21 KiB
C
838 lines
21 KiB
C
/* fsclient.c: AFS File Server client stubs
|
|
*
|
|
* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/sched.h>
|
|
#include <rxrpc/rxrpc.h>
|
|
#include <rxrpc/transport.h>
|
|
#include <rxrpc/connection.h>
|
|
#include <rxrpc/call.h>
|
|
#include "fsclient.h"
|
|
#include "cmservice.h"
|
|
#include "vnode.h"
|
|
#include "server.h"
|
|
#include "errors.h"
|
|
#include "internal.h"
|
|
|
|
#define FSFETCHSTATUS 132 /* AFS Fetch file status */
|
|
#define FSFETCHDATA 130 /* AFS Fetch file data */
|
|
#define FSGIVEUPCALLBACKS 147 /* AFS Discard callback promises */
|
|
#define FSGETVOLUMEINFO 148 /* AFS Get root volume information */
|
|
#define FSGETROOTVOLUME 151 /* AFS Get root volume name */
|
|
#define FSLOOKUP 161 /* AFS lookup file in directory */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* map afs abort codes to/from Linux error codes
|
|
* - called with call->lock held
|
|
*/
|
|
static void afs_rxfs_aemap(struct rxrpc_call *call)
|
|
{
|
|
switch (call->app_err_state) {
|
|
case RXRPC_ESTATE_LOCAL_ABORT:
|
|
call->app_abort_code = -call->app_errno;
|
|
break;
|
|
case RXRPC_ESTATE_PEER_ABORT:
|
|
call->app_errno = afs_abort_to_error(call->app_abort_code);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} /* end afs_rxfs_aemap() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* get the root volume name from a fileserver
|
|
* - this operation doesn't seem to work correctly in OpenAFS server 1.2.2
|
|
*/
|
|
#if 0
|
|
int afs_rxfs_get_root_volume(struct afs_server *server,
|
|
char *buf, size_t *buflen)
|
|
{
|
|
struct rxrpc_connection *conn;
|
|
struct rxrpc_call *call;
|
|
struct kvec piov[2];
|
|
size_t sent;
|
|
int ret;
|
|
u32 param[1];
|
|
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
kenter("%p,%p,%u",server, buf, *buflen);
|
|
|
|
/* get hold of the fileserver connection */
|
|
ret = afs_server_get_fsconn(server, &conn);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
/* create a call through that connection */
|
|
ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
|
|
if (ret < 0) {
|
|
printk("kAFS: Unable to create call: %d\n", ret);
|
|
goto out_put_conn;
|
|
}
|
|
call->app_opcode = FSGETROOTVOLUME;
|
|
|
|
/* we want to get event notifications from the call */
|
|
add_wait_queue(&call->waitq, &myself);
|
|
|
|
/* marshall the parameters */
|
|
param[0] = htonl(FSGETROOTVOLUME);
|
|
|
|
piov[0].iov_len = sizeof(param);
|
|
piov[0].iov_base = param;
|
|
|
|
/* send the parameters to the server */
|
|
ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
|
|
0, &sent);
|
|
if (ret < 0)
|
|
goto abort;
|
|
|
|
/* wait for the reply to completely arrive */
|
|
for (;;) {
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
|
|
signal_pending(current))
|
|
break;
|
|
schedule();
|
|
}
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
ret = -EINTR;
|
|
if (signal_pending(current))
|
|
goto abort;
|
|
|
|
switch (call->app_call_state) {
|
|
case RXRPC_CSTATE_ERROR:
|
|
ret = call->app_errno;
|
|
kdebug("Got Error: %d", ret);
|
|
goto out_unwait;
|
|
|
|
case RXRPC_CSTATE_CLNT_GOT_REPLY:
|
|
/* read the reply */
|
|
kdebug("Got Reply: qty=%d", call->app_ready_qty);
|
|
|
|
ret = -EBADMSG;
|
|
if (call->app_ready_qty <= 4)
|
|
goto abort;
|
|
|
|
ret = rxrpc_call_read_data(call, NULL, call->app_ready_qty, 0);
|
|
if (ret < 0)
|
|
goto abort;
|
|
|
|
#if 0
|
|
/* unmarshall the reply */
|
|
bp = buffer;
|
|
for (loop = 0; loop < 65; loop++)
|
|
entry->name[loop] = ntohl(*bp++);
|
|
entry->name[64] = 0;
|
|
|
|
entry->type = ntohl(*bp++);
|
|
entry->num_servers = ntohl(*bp++);
|
|
|
|
for (loop = 0; loop < 8; loop++)
|
|
entry->servers[loop].addr.s_addr = *bp++;
|
|
|
|
for (loop = 0; loop < 8; loop++)
|
|
entry->servers[loop].partition = ntohl(*bp++);
|
|
|
|
for (loop = 0; loop < 8; loop++)
|
|
entry->servers[loop].flags = ntohl(*bp++);
|
|
|
|
for (loop = 0; loop < 3; loop++)
|
|
entry->volume_ids[loop] = ntohl(*bp++);
|
|
|
|
entry->clone_id = ntohl(*bp++);
|
|
entry->flags = ntohl(*bp);
|
|
#endif
|
|
|
|
/* success */
|
|
ret = 0;
|
|
goto out_unwait;
|
|
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
abort:
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
rxrpc_call_abort(call, ret);
|
|
schedule();
|
|
out_unwait:
|
|
set_current_state(TASK_RUNNING);
|
|
remove_wait_queue(&call->waitq, &myself);
|
|
rxrpc_put_call(call);
|
|
out_put_conn:
|
|
afs_server_release_fsconn(server, conn);
|
|
out:
|
|
kleave("");
|
|
return ret;
|
|
} /* end afs_rxfs_get_root_volume() */
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* get information about a volume
|
|
*/
|
|
#if 0
|
|
int afs_rxfs_get_volume_info(struct afs_server *server,
|
|
const char *name,
|
|
struct afs_volume_info *vinfo)
|
|
{
|
|
struct rxrpc_connection *conn;
|
|
struct rxrpc_call *call;
|
|
struct kvec piov[3];
|
|
size_t sent;
|
|
int ret;
|
|
u32 param[2], *bp, zero;
|
|
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
_enter("%p,%s,%p", server, name, vinfo);
|
|
|
|
/* get hold of the fileserver connection */
|
|
ret = afs_server_get_fsconn(server, &conn);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
/* create a call through that connection */
|
|
ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
|
|
if (ret < 0) {
|
|
printk("kAFS: Unable to create call: %d\n", ret);
|
|
goto out_put_conn;
|
|
}
|
|
call->app_opcode = FSGETVOLUMEINFO;
|
|
|
|
/* we want to get event notifications from the call */
|
|
add_wait_queue(&call->waitq, &myself);
|
|
|
|
/* marshall the parameters */
|
|
piov[1].iov_len = strlen(name);
|
|
piov[1].iov_base = (char *) name;
|
|
|
|
zero = 0;
|
|
piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
|
|
piov[2].iov_base = &zero;
|
|
|
|
param[0] = htonl(FSGETVOLUMEINFO);
|
|
param[1] = htonl(piov[1].iov_len);
|
|
|
|
piov[0].iov_len = sizeof(param);
|
|
piov[0].iov_base = param;
|
|
|
|
/* send the parameters to the server */
|
|
ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
|
|
0, &sent);
|
|
if (ret < 0)
|
|
goto abort;
|
|
|
|
/* wait for the reply to completely arrive */
|
|
bp = rxrpc_call_alloc_scratch(call, 64);
|
|
|
|
ret = rxrpc_call_read_data(call, bp, 64,
|
|
RXRPC_CALL_READ_BLOCK |
|
|
RXRPC_CALL_READ_ALL);
|
|
if (ret < 0) {
|
|
if (ret == -ECONNABORTED) {
|
|
ret = call->app_errno;
|
|
goto out_unwait;
|
|
}
|
|
goto abort;
|
|
}
|
|
|
|
/* unmarshall the reply */
|
|
vinfo->vid = ntohl(*bp++);
|
|
vinfo->type = ntohl(*bp++);
|
|
|
|
vinfo->type_vids[0] = ntohl(*bp++);
|
|
vinfo->type_vids[1] = ntohl(*bp++);
|
|
vinfo->type_vids[2] = ntohl(*bp++);
|
|
vinfo->type_vids[3] = ntohl(*bp++);
|
|
vinfo->type_vids[4] = ntohl(*bp++);
|
|
|
|
vinfo->nservers = ntohl(*bp++);
|
|
vinfo->servers[0].addr.s_addr = *bp++;
|
|
vinfo->servers[1].addr.s_addr = *bp++;
|
|
vinfo->servers[2].addr.s_addr = *bp++;
|
|
vinfo->servers[3].addr.s_addr = *bp++;
|
|
vinfo->servers[4].addr.s_addr = *bp++;
|
|
vinfo->servers[5].addr.s_addr = *bp++;
|
|
vinfo->servers[6].addr.s_addr = *bp++;
|
|
vinfo->servers[7].addr.s_addr = *bp++;
|
|
|
|
ret = -EBADMSG;
|
|
if (vinfo->nservers > 8)
|
|
goto abort;
|
|
|
|
/* success */
|
|
ret = 0;
|
|
|
|
out_unwait:
|
|
set_current_state(TASK_RUNNING);
|
|
remove_wait_queue(&call->waitq, &myself);
|
|
rxrpc_put_call(call);
|
|
out_put_conn:
|
|
afs_server_release_fsconn(server, conn);
|
|
out:
|
|
_leave("");
|
|
return ret;
|
|
|
|
abort:
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
rxrpc_call_abort(call, ret);
|
|
schedule();
|
|
goto out_unwait;
|
|
|
|
} /* end afs_rxfs_get_volume_info() */
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* fetch the status information for a file
|
|
*/
|
|
int afs_rxfs_fetch_file_status(struct afs_server *server,
|
|
struct afs_vnode *vnode,
|
|
struct afs_volsync *volsync)
|
|
{
|
|
struct afs_server_callslot callslot;
|
|
struct rxrpc_call *call;
|
|
struct kvec piov[1];
|
|
size_t sent;
|
|
int ret;
|
|
__be32 *bp;
|
|
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
_enter("%p,{%u,%u,%u}",
|
|
server, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
|
|
|
|
/* get hold of the fileserver connection */
|
|
ret = afs_server_request_callslot(server, &callslot);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
/* create a call through that connection */
|
|
ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap,
|
|
&call);
|
|
if (ret < 0) {
|
|
printk("kAFS: Unable to create call: %d\n", ret);
|
|
goto out_put_conn;
|
|
}
|
|
call->app_opcode = FSFETCHSTATUS;
|
|
|
|
/* we want to get event notifications from the call */
|
|
add_wait_queue(&call->waitq, &myself);
|
|
|
|
/* marshall the parameters */
|
|
bp = rxrpc_call_alloc_scratch(call, 16);
|
|
bp[0] = htonl(FSFETCHSTATUS);
|
|
bp[1] = htonl(vnode->fid.vid);
|
|
bp[2] = htonl(vnode->fid.vnode);
|
|
bp[3] = htonl(vnode->fid.unique);
|
|
|
|
piov[0].iov_len = 16;
|
|
piov[0].iov_base = bp;
|
|
|
|
/* send the parameters to the server */
|
|
ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
|
|
0, &sent);
|
|
if (ret < 0)
|
|
goto abort;
|
|
|
|
/* wait for the reply to completely arrive */
|
|
bp = rxrpc_call_alloc_scratch(call, 120);
|
|
|
|
ret = rxrpc_call_read_data(call, bp, 120,
|
|
RXRPC_CALL_READ_BLOCK |
|
|
RXRPC_CALL_READ_ALL);
|
|
if (ret < 0) {
|
|
if (ret == -ECONNABORTED) {
|
|
ret = call->app_errno;
|
|
goto out_unwait;
|
|
}
|
|
goto abort;
|
|
}
|
|
|
|
/* unmarshall the reply */
|
|
vnode->status.if_version = ntohl(*bp++);
|
|
vnode->status.type = ntohl(*bp++);
|
|
vnode->status.nlink = ntohl(*bp++);
|
|
vnode->status.size = ntohl(*bp++);
|
|
vnode->status.version = ntohl(*bp++);
|
|
vnode->status.author = ntohl(*bp++);
|
|
vnode->status.owner = ntohl(*bp++);
|
|
vnode->status.caller_access = ntohl(*bp++);
|
|
vnode->status.anon_access = ntohl(*bp++);
|
|
vnode->status.mode = ntohl(*bp++);
|
|
vnode->status.parent.vid = vnode->fid.vid;
|
|
vnode->status.parent.vnode = ntohl(*bp++);
|
|
vnode->status.parent.unique = ntohl(*bp++);
|
|
bp++; /* seg size */
|
|
vnode->status.mtime_client = ntohl(*bp++);
|
|
vnode->status.mtime_server = ntohl(*bp++);
|
|
bp++; /* group */
|
|
bp++; /* sync counter */
|
|
vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
|
|
bp++; /* spare2 */
|
|
bp++; /* spare3 */
|
|
bp++; /* spare4 */
|
|
|
|
vnode->cb_version = ntohl(*bp++);
|
|
vnode->cb_expiry = ntohl(*bp++);
|
|
vnode->cb_type = ntohl(*bp++);
|
|
|
|
if (volsync) {
|
|
volsync->creation = ntohl(*bp++);
|
|
bp++; /* spare2 */
|
|
bp++; /* spare3 */
|
|
bp++; /* spare4 */
|
|
bp++; /* spare5 */
|
|
bp++; /* spare6 */
|
|
}
|
|
|
|
/* success */
|
|
ret = 0;
|
|
|
|
out_unwait:
|
|
set_current_state(TASK_RUNNING);
|
|
remove_wait_queue(&call->waitq, &myself);
|
|
rxrpc_put_call(call);
|
|
out_put_conn:
|
|
afs_server_release_callslot(server, &callslot);
|
|
out:
|
|
_leave("");
|
|
return ret;
|
|
|
|
abort:
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
rxrpc_call_abort(call, ret);
|
|
schedule();
|
|
goto out_unwait;
|
|
} /* end afs_rxfs_fetch_file_status() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* fetch the contents of a file or directory
|
|
*/
|
|
int afs_rxfs_fetch_file_data(struct afs_server *server,
|
|
struct afs_vnode *vnode,
|
|
struct afs_rxfs_fetch_descriptor *desc,
|
|
struct afs_volsync *volsync)
|
|
{
|
|
struct afs_server_callslot callslot;
|
|
struct rxrpc_call *call;
|
|
struct kvec piov[1];
|
|
size_t sent;
|
|
int ret;
|
|
__be32 *bp;
|
|
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
_enter("%p,{fid={%u,%u,%u},sz=%Zu,of=%lu}",
|
|
server,
|
|
desc->fid.vid,
|
|
desc->fid.vnode,
|
|
desc->fid.unique,
|
|
desc->size,
|
|
desc->offset);
|
|
|
|
/* get hold of the fileserver connection */
|
|
ret = afs_server_request_callslot(server, &callslot);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
/* create a call through that connection */
|
|
ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap, &call);
|
|
if (ret < 0) {
|
|
printk("kAFS: Unable to create call: %d\n", ret);
|
|
goto out_put_conn;
|
|
}
|
|
call->app_opcode = FSFETCHDATA;
|
|
|
|
/* we want to get event notifications from the call */
|
|
add_wait_queue(&call->waitq, &myself);
|
|
|
|
/* marshall the parameters */
|
|
bp = rxrpc_call_alloc_scratch(call, 24);
|
|
bp[0] = htonl(FSFETCHDATA);
|
|
bp[1] = htonl(desc->fid.vid);
|
|
bp[2] = htonl(desc->fid.vnode);
|
|
bp[3] = htonl(desc->fid.unique);
|
|
bp[4] = htonl(desc->offset);
|
|
bp[5] = htonl(desc->size);
|
|
|
|
piov[0].iov_len = 24;
|
|
piov[0].iov_base = bp;
|
|
|
|
/* send the parameters to the server */
|
|
ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
|
|
0, &sent);
|
|
if (ret < 0)
|
|
goto abort;
|
|
|
|
/* wait for the data count to arrive */
|
|
ret = rxrpc_call_read_data(call, bp, 4, RXRPC_CALL_READ_BLOCK);
|
|
if (ret < 0)
|
|
goto read_failed;
|
|
|
|
desc->actual = ntohl(bp[0]);
|
|
if (desc->actual != desc->size) {
|
|
ret = -EBADMSG;
|
|
goto abort;
|
|
}
|
|
|
|
/* call the app to read the actual data */
|
|
rxrpc_call_reset_scratch(call);
|
|
|
|
ret = rxrpc_call_read_data(call, desc->buffer, desc->actual,
|
|
RXRPC_CALL_READ_BLOCK);
|
|
if (ret < 0)
|
|
goto read_failed;
|
|
|
|
/* wait for the rest of the reply to completely arrive */
|
|
rxrpc_call_reset_scratch(call);
|
|
bp = rxrpc_call_alloc_scratch(call, 120);
|
|
|
|
ret = rxrpc_call_read_data(call, bp, 120,
|
|
RXRPC_CALL_READ_BLOCK |
|
|
RXRPC_CALL_READ_ALL);
|
|
if (ret < 0)
|
|
goto read_failed;
|
|
|
|
/* unmarshall the reply */
|
|
vnode->status.if_version = ntohl(*bp++);
|
|
vnode->status.type = ntohl(*bp++);
|
|
vnode->status.nlink = ntohl(*bp++);
|
|
vnode->status.size = ntohl(*bp++);
|
|
vnode->status.version = ntohl(*bp++);
|
|
vnode->status.author = ntohl(*bp++);
|
|
vnode->status.owner = ntohl(*bp++);
|
|
vnode->status.caller_access = ntohl(*bp++);
|
|
vnode->status.anon_access = ntohl(*bp++);
|
|
vnode->status.mode = ntohl(*bp++);
|
|
vnode->status.parent.vid = desc->fid.vid;
|
|
vnode->status.parent.vnode = ntohl(*bp++);
|
|
vnode->status.parent.unique = ntohl(*bp++);
|
|
bp++; /* seg size */
|
|
vnode->status.mtime_client = ntohl(*bp++);
|
|
vnode->status.mtime_server = ntohl(*bp++);
|
|
bp++; /* group */
|
|
bp++; /* sync counter */
|
|
vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
|
|
bp++; /* spare2 */
|
|
bp++; /* spare3 */
|
|
bp++; /* spare4 */
|
|
|
|
vnode->cb_version = ntohl(*bp++);
|
|
vnode->cb_expiry = ntohl(*bp++);
|
|
vnode->cb_type = ntohl(*bp++);
|
|
|
|
if (volsync) {
|
|
volsync->creation = ntohl(*bp++);
|
|
bp++; /* spare2 */
|
|
bp++; /* spare3 */
|
|
bp++; /* spare4 */
|
|
bp++; /* spare5 */
|
|
bp++; /* spare6 */
|
|
}
|
|
|
|
/* success */
|
|
ret = 0;
|
|
|
|
out_unwait:
|
|
set_current_state(TASK_RUNNING);
|
|
remove_wait_queue(&call->waitq,&myself);
|
|
rxrpc_put_call(call);
|
|
out_put_conn:
|
|
afs_server_release_callslot(server, &callslot);
|
|
out:
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
|
|
read_failed:
|
|
if (ret == -ECONNABORTED) {
|
|
ret = call->app_errno;
|
|
goto out_unwait;
|
|
}
|
|
|
|
abort:
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
rxrpc_call_abort(call, ret);
|
|
schedule();
|
|
goto out_unwait;
|
|
|
|
} /* end afs_rxfs_fetch_file_data() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* ask the AFS fileserver to discard a callback request on a file
|
|
*/
|
|
int afs_rxfs_give_up_callback(struct afs_server *server,
|
|
struct afs_vnode *vnode)
|
|
{
|
|
struct afs_server_callslot callslot;
|
|
struct rxrpc_call *call;
|
|
struct kvec piov[1];
|
|
size_t sent;
|
|
int ret;
|
|
__be32 *bp;
|
|
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
_enter("%p,{%u,%u,%u}",
|
|
server, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
|
|
|
|
/* get hold of the fileserver connection */
|
|
ret = afs_server_request_callslot(server, &callslot);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
/* create a call through that connection */
|
|
ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap, &call);
|
|
if (ret < 0) {
|
|
printk("kAFS: Unable to create call: %d\n", ret);
|
|
goto out_put_conn;
|
|
}
|
|
call->app_opcode = FSGIVEUPCALLBACKS;
|
|
|
|
/* we want to get event notifications from the call */
|
|
add_wait_queue(&call->waitq, &myself);
|
|
|
|
/* marshall the parameters */
|
|
bp = rxrpc_call_alloc_scratch(call, (1 + 4 + 4) * 4);
|
|
|
|
piov[0].iov_len = (1 + 4 + 4) * 4;
|
|
piov[0].iov_base = bp;
|
|
|
|
*bp++ = htonl(FSGIVEUPCALLBACKS);
|
|
*bp++ = htonl(1);
|
|
*bp++ = htonl(vnode->fid.vid);
|
|
*bp++ = htonl(vnode->fid.vnode);
|
|
*bp++ = htonl(vnode->fid.unique);
|
|
*bp++ = htonl(1);
|
|
*bp++ = htonl(vnode->cb_version);
|
|
*bp++ = htonl(vnode->cb_expiry);
|
|
*bp++ = htonl(vnode->cb_type);
|
|
|
|
/* send the parameters to the server */
|
|
ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
|
|
0, &sent);
|
|
if (ret < 0)
|
|
goto abort;
|
|
|
|
/* wait for the reply to completely arrive */
|
|
for (;;) {
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
|
|
signal_pending(current))
|
|
break;
|
|
schedule();
|
|
}
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
ret = -EINTR;
|
|
if (signal_pending(current))
|
|
goto abort;
|
|
|
|
switch (call->app_call_state) {
|
|
case RXRPC_CSTATE_ERROR:
|
|
ret = call->app_errno;
|
|
goto out_unwait;
|
|
|
|
case RXRPC_CSTATE_CLNT_GOT_REPLY:
|
|
ret = 0;
|
|
goto out_unwait;
|
|
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
out_unwait:
|
|
set_current_state(TASK_RUNNING);
|
|
remove_wait_queue(&call->waitq, &myself);
|
|
rxrpc_put_call(call);
|
|
out_put_conn:
|
|
afs_server_release_callslot(server, &callslot);
|
|
out:
|
|
_leave("");
|
|
return ret;
|
|
|
|
abort:
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
rxrpc_call_abort(call, ret);
|
|
schedule();
|
|
goto out_unwait;
|
|
} /* end afs_rxfs_give_up_callback() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* look a filename up in a directory
|
|
* - this operation doesn't seem to work correctly in OpenAFS server 1.2.2
|
|
*/
|
|
#if 0
|
|
int afs_rxfs_lookup(struct afs_server *server,
|
|
struct afs_vnode *dir,
|
|
const char *filename,
|
|
struct afs_vnode *vnode,
|
|
struct afs_volsync *volsync)
|
|
{
|
|
struct rxrpc_connection *conn;
|
|
struct rxrpc_call *call;
|
|
struct kvec piov[3];
|
|
size_t sent;
|
|
int ret;
|
|
u32 *bp, zero;
|
|
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
kenter("%p,{%u,%u,%u},%s",
|
|
server, fid->vid, fid->vnode, fid->unique, filename);
|
|
|
|
/* get hold of the fileserver connection */
|
|
ret = afs_server_get_fsconn(server, &conn);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
/* create a call through that connection */
|
|
ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
|
|
if (ret < 0) {
|
|
printk("kAFS: Unable to create call: %d\n", ret);
|
|
goto out_put_conn;
|
|
}
|
|
call->app_opcode = FSLOOKUP;
|
|
|
|
/* we want to get event notifications from the call */
|
|
add_wait_queue(&call->waitq,&myself);
|
|
|
|
/* marshall the parameters */
|
|
bp = rxrpc_call_alloc_scratch(call, 20);
|
|
|
|
zero = 0;
|
|
|
|
piov[0].iov_len = 20;
|
|
piov[0].iov_base = bp;
|
|
piov[1].iov_len = strlen(filename);
|
|
piov[1].iov_base = (char *) filename;
|
|
piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
|
|
piov[2].iov_base = &zero;
|
|
|
|
*bp++ = htonl(FSLOOKUP);
|
|
*bp++ = htonl(dirfid->vid);
|
|
*bp++ = htonl(dirfid->vnode);
|
|
*bp++ = htonl(dirfid->unique);
|
|
*bp++ = htonl(piov[1].iov_len);
|
|
|
|
/* send the parameters to the server */
|
|
ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
|
|
0, &sent);
|
|
if (ret < 0)
|
|
goto abort;
|
|
|
|
/* wait for the reply to completely arrive */
|
|
bp = rxrpc_call_alloc_scratch(call, 220);
|
|
|
|
ret = rxrpc_call_read_data(call, bp, 220,
|
|
RXRPC_CALL_READ_BLOCK |
|
|
RXRPC_CALL_READ_ALL);
|
|
if (ret < 0) {
|
|
if (ret == -ECONNABORTED) {
|
|
ret = call->app_errno;
|
|
goto out_unwait;
|
|
}
|
|
goto abort;
|
|
}
|
|
|
|
/* unmarshall the reply */
|
|
fid->vid = ntohl(*bp++);
|
|
fid->vnode = ntohl(*bp++);
|
|
fid->unique = ntohl(*bp++);
|
|
|
|
vnode->status.if_version = ntohl(*bp++);
|
|
vnode->status.type = ntohl(*bp++);
|
|
vnode->status.nlink = ntohl(*bp++);
|
|
vnode->status.size = ntohl(*bp++);
|
|
vnode->status.version = ntohl(*bp++);
|
|
vnode->status.author = ntohl(*bp++);
|
|
vnode->status.owner = ntohl(*bp++);
|
|
vnode->status.caller_access = ntohl(*bp++);
|
|
vnode->status.anon_access = ntohl(*bp++);
|
|
vnode->status.mode = ntohl(*bp++);
|
|
vnode->status.parent.vid = dirfid->vid;
|
|
vnode->status.parent.vnode = ntohl(*bp++);
|
|
vnode->status.parent.unique = ntohl(*bp++);
|
|
bp++; /* seg size */
|
|
vnode->status.mtime_client = ntohl(*bp++);
|
|
vnode->status.mtime_server = ntohl(*bp++);
|
|
bp++; /* group */
|
|
bp++; /* sync counter */
|
|
vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
|
|
bp++; /* spare2 */
|
|
bp++; /* spare3 */
|
|
bp++; /* spare4 */
|
|
|
|
dir->status.if_version = ntohl(*bp++);
|
|
dir->status.type = ntohl(*bp++);
|
|
dir->status.nlink = ntohl(*bp++);
|
|
dir->status.size = ntohl(*bp++);
|
|
dir->status.version = ntohl(*bp++);
|
|
dir->status.author = ntohl(*bp++);
|
|
dir->status.owner = ntohl(*bp++);
|
|
dir->status.caller_access = ntohl(*bp++);
|
|
dir->status.anon_access = ntohl(*bp++);
|
|
dir->status.mode = ntohl(*bp++);
|
|
dir->status.parent.vid = dirfid->vid;
|
|
dir->status.parent.vnode = ntohl(*bp++);
|
|
dir->status.parent.unique = ntohl(*bp++);
|
|
bp++; /* seg size */
|
|
dir->status.mtime_client = ntohl(*bp++);
|
|
dir->status.mtime_server = ntohl(*bp++);
|
|
bp++; /* group */
|
|
bp++; /* sync counter */
|
|
dir->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
|
|
bp++; /* spare2 */
|
|
bp++; /* spare3 */
|
|
bp++; /* spare4 */
|
|
|
|
callback->fid = *fid;
|
|
callback->version = ntohl(*bp++);
|
|
callback->expiry = ntohl(*bp++);
|
|
callback->type = ntohl(*bp++);
|
|
|
|
if (volsync) {
|
|
volsync->creation = ntohl(*bp++);
|
|
bp++; /* spare2 */
|
|
bp++; /* spare3 */
|
|
bp++; /* spare4 */
|
|
bp++; /* spare5 */
|
|
bp++; /* spare6 */
|
|
}
|
|
|
|
/* success */
|
|
ret = 0;
|
|
|
|
out_unwait:
|
|
set_current_state(TASK_RUNNING);
|
|
remove_wait_queue(&call->waitq, &myself);
|
|
rxrpc_put_call(call);
|
|
out_put_conn:
|
|
afs_server_release_fsconn(server, conn);
|
|
out:
|
|
kleave("");
|
|
return ret;
|
|
|
|
abort:
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
rxrpc_call_abort(call, ret);
|
|
schedule();
|
|
goto out_unwait;
|
|
} /* end afs_rxfs_lookup() */
|
|
#endif
|