cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

coxattr.c (2829B)

      1/*
      2 * 9p backend
      3 *
      4 * Copyright IBM, Corp. 2011
      5 *
      6 * Authors:
      7 *  Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
      8 *
      9 * This work is licensed under the terms of the GNU GPL, version 2.  See
     10 * the COPYING file in the top-level directory.
     11 *
     12 */
     13
     14/*
     15 * Not so fast! You might want to read the 9p developer docs first:
     16 * https://wiki.qemu.org/Documentation/9p
     17 */
     18
     19#include "qemu/osdep.h"
     20#include "fsdev/qemu-fsdev.h"
     21#include "qemu/thread.h"
     22#include "qemu/coroutine.h"
     23#include "qemu/main-loop.h"
     24#include "coth.h"
     25
     26int coroutine_fn v9fs_co_llistxattr(V9fsPDU *pdu, V9fsPath *path, void *value,
     27                                    size_t size)
     28{
     29    int err;
     30    V9fsState *s = pdu->s;
     31
     32    if (v9fs_request_cancelled(pdu)) {
     33        return -EINTR;
     34    }
     35    v9fs_path_read_lock(s);
     36    v9fs_co_run_in_worker(
     37        {
     38            err = s->ops->llistxattr(&s->ctx, path, value, size);
     39            if (err < 0) {
     40                err = -errno;
     41            }
     42        });
     43    v9fs_path_unlock(s);
     44    return err;
     45}
     46
     47int coroutine_fn v9fs_co_lgetxattr(V9fsPDU *pdu, V9fsPath *path,
     48                                   V9fsString *xattr_name, void *value,
     49                                   size_t size)
     50{
     51    int err;
     52    V9fsState *s = pdu->s;
     53
     54    if (v9fs_request_cancelled(pdu)) {
     55        return -EINTR;
     56    }
     57    v9fs_path_read_lock(s);
     58    v9fs_co_run_in_worker(
     59        {
     60            err = s->ops->lgetxattr(&s->ctx, path,
     61                                    xattr_name->data,
     62                                    value, size);
     63            if (err < 0) {
     64                err = -errno;
     65            }
     66        });
     67    v9fs_path_unlock(s);
     68    return err;
     69}
     70
     71int coroutine_fn v9fs_co_lsetxattr(V9fsPDU *pdu, V9fsPath *path,
     72                                   V9fsString *xattr_name, void *value,
     73                                   size_t size, int flags)
     74{
     75    int err;
     76    V9fsState *s = pdu->s;
     77
     78    if (v9fs_request_cancelled(pdu)) {
     79        return -EINTR;
     80    }
     81    v9fs_path_read_lock(s);
     82    v9fs_co_run_in_worker(
     83        {
     84            err = s->ops->lsetxattr(&s->ctx, path,
     85                                    xattr_name->data, value,
     86                                    size, flags);
     87            if (err < 0) {
     88                err = -errno;
     89            }
     90        });
     91    v9fs_path_unlock(s);
     92    return err;
     93}
     94
     95int coroutine_fn v9fs_co_lremovexattr(V9fsPDU *pdu, V9fsPath *path,
     96                                      V9fsString *xattr_name)
     97{
     98    int err;
     99    V9fsState *s = pdu->s;
    100
    101    if (v9fs_request_cancelled(pdu)) {
    102        return -EINTR;
    103    }
    104    v9fs_path_read_lock(s);
    105    v9fs_co_run_in_worker(
    106        {
    107            err = s->ops->lremovexattr(&s->ctx, path, xattr_name->data);
    108            if (err < 0) {
    109                err = -errno;
    110            }
    111        });
    112    v9fs_path_unlock(s);
    113    return err;
    114}