Commit 82cc3ee8 authored by M. Mohan Kumar's avatar M. Mohan Kumar Committed by Anthony Liguori

[virto-9p] Implement TLOCK


    size[4] TLock tag[2] fid[4] flock[n]
    size[4] RLock tag[2] status[1]


Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request

    flock structure:
        type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
        flags[4] - Flags could be either of
          P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
            conflicting lock exists, wait for that lock to be released.
          P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
            trying to reclaim a lock after a server restrart (due to crash)
        start[8] - Starting offset for lock
        length[8] - Number of bytes to lock
          If length is 0, lock all bytes starting at the location 'start'
          through to the end of file
        pid[4] - PID of the process that wants to take lock
        client_id[4] - Unique client id

        status[1] - Status of the lock request, can be
          P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
          P9_LOCK_SUCCESS - Request was successful
          P9_LOCK_BLOCKED - A conflicting lock is held by another process
          P9_LOCK_ERROR - Error while processing the lock request
          P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
                requests in this period (except locks with
                P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: default avatarM. Mohan Kumar <>
Signed-off-by: default avatarAneesh Kumar K.V <>
Signed-off-by: default avatarVenkateswararao Jujjuri <>
parent ab03b63d
......@@ -588,6 +588,20 @@ void pprint_pdu(V9fsPDU *pdu)
fprintf(llogfile, "RXATTRCREATE: (");
case P9_TLOCK:
fprintf(llogfile, "TLOCK: (");
pprint_int32(pdu, 0, &offset, "fid");
pprint_int8(pdu, 0, &offset, ", type");
pprint_int32(pdu, 0, &offset, ", flags");
pprint_int64(pdu, 0, &offset, ", start");
pprint_int64(pdu, 0, &offset, ", length");
pprint_int32(pdu, 0, &offset, ", proc_id");
pprint_str(pdu, 0, &offset, ", client_id");
case P9_RLOCK:
fprintf(llogfile, "RLOCK: (");
pprint_int8(pdu, 0, &offset, "status");
fprintf(llogfile, "unknown(%d): (", pdu->id);
......@@ -3154,6 +3154,55 @@ out:
* Implement posix byte range locking code
* Server side handling of locking code is very simple, because 9p server in
* QEMU can handle only one client. And most of the lock handling
* (like conflict, merging) etc is done by the VFS layer itself, so no need to
* do any thing in * qemu 9p server side lock code path.
* So when a TLOCK request comes, always return success
static void v9fs_lock(V9fsState *s, V9fsPDU *pdu)
int32_t fid, err = 0;
V9fsLockState *vs;
vs = qemu_mallocz(sizeof(*vs));
vs->pdu = pdu;
vs->offset = 7;
vs->flock = qemu_malloc(sizeof(*vs->flock));
pdu_unmarshal(vs->pdu, vs->offset, "dbdqqds", &fid, &vs->flock->type,
&vs->flock->flags, &vs->flock->start, &vs->flock->length,
&vs->flock->proc_id, &vs->flock->client_id);
vs->status = P9_LOCK_ERROR;
/* We support only block flag now (that too ignored currently) */
if (vs->flock->flags & ~P9_LOCK_FLAGS_BLOCK) {
err = -EINVAL;
goto out;
vs->fidp = lookup_fid(s, fid);
if (vs->fidp == NULL) {
err = -ENOENT;
goto out;
err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
if (err < 0) {
err = -errno;
goto out;
vs->status = P9_LOCK_SUCCESS;
vs->offset += pdu_marshal(vs->pdu, vs->offset, "b", vs->status);
complete_pdu(s, vs->pdu, err);
static void v9fs_mkdir_post_lstat(V9fsState *s, V9fsMkState *vs, int err)
if (err == -1) {
......@@ -3416,6 +3465,7 @@ static pdu_handler_t *pdu_handlers[] = {
[P9_TXATTRCREATE] = v9fs_xattrcreate,
[P9_TMKNOD] = v9fs_mknod,
[P9_TRENAME] = v9fs_rename,
[P9_TLOCK] = v9fs_lock,
[P9_TMKDIR] = v9fs_mkdir,
[P9_TVERSION] = v9fs_version,
[P9_TLOPEN] = v9fs_open,
......@@ -37,6 +37,8 @@ enum {
P9_TLOCK = 52,
P9_TLINK = 70,
P9_TMKDIR = 72,
......@@ -434,6 +436,34 @@ typedef struct V9fsXattrState
void *value;
} V9fsXattrState;
#define P9_LOCK_SUCCESS 0
#define P9_LOCK_BLOCKED 1
#define P9_LOCK_ERROR 2
#define P9_LOCK_GRACE 3
typedef struct V9fsFlock
uint8_t type;
uint32_t flags;
uint64_t start; /* absolute offset */
uint64_t length;
uint32_t proc_id;
V9fsString client_id;
} V9fsFlock;
typedef struct V9fsLockState
V9fsPDU *pdu;
size_t offset;
int8_t status;
struct stat stbuf;
V9fsFidState *fidp;
V9fsFlock *flock;
} V9fsLockState;
extern size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count,
size_t offset, size_t size, int pack);
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment