1

#include "cache.h"

     2

#include "shared/util.h"

     3

#include "shared/log.h" // only LOG_DEBUG

     4

#include "error.h"

     5

     6

#include <stdlib.h>

     7

#include <unistd.h>

     8

#include <sys/types.h>

     9

#include <sys/stat.h>

    10

#include <fcntl.h>

    11

#include <sys/mman.h>

    12

#include <errno.h>

    13

#include <assert.h>

    14

    15

    16

int pt_cache_new (struct pt_cache **cache_ptr, const char *path, int mode)

    17

{

    18

    struct pt_cache *cache;

    19

    int err;

    20

    21

    // alloc

    22

    if ((cache = calloc(1, sizeof(*cache))) == NULL)

    23

        RETURN_ERROR(PT_ERR_MEM);

    24

    25

    if ((cache->path = strdup(path)) == NULL)

    26

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    27

    28

    // init

    29

    cache->fd = -1;

    30

    cache->mode = mode;

    31

    32

    // ok

    33

    *cache_ptr = cache;

    34

    35

    return 0;

    36

    37

error:

    38

    // cleanup

    39

    if (cache)

    40

        pt_cache_destroy(cache);

    41

    42

    return err;

    43

}

    44

    45

/**

    46

 * Force-clean pt_cache, warn on errors

    47

 */

    48

static void pt_cache_abort (struct pt_cache *cache)

    49

{

    50

    if (cache->file != NULL) {

    51

        if (munmap(cache->file, sizeof(struct pt_cache_file) + cache->file->header.data_size))

    52

            log_warn_errno("munmap: %p, %zu", cache->file, sizeof(struct pt_cache_file) + cache->file->header.data_size);

    53

    54

        cache->file = NULL;

    55

    }

    56

    57

    if (cache->fd >= 0) {

    58

        if (close(cache->fd))

    59

            log_warn_errno("close: %d", cache->fd);

    60

    61

        cache->fd = -1;

    62

    }

    63

}

    64

    65

/**

    66

 * Open the cache file as an fd for reading

    67

 *

    68

 * XXX: use some kind of locking?

    69

 */

    70

static int pt_cache_open_read_fd (struct pt_cache *cache, int *fd_ptr)

    71

{

    72

    int fd;

    73

    74

    // actual open()

    75

    if ((fd = open(cache->path, O_RDONLY)) < 0)

    76

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

    77

    78

    // ok

    79

    *fd_ptr = fd;

    80

    81

    return 0;

    82

}

    83

    84

/**

    85

 * Read in the cache header from the open file

    86

 */

    87

static int pt_cache_read_header (int fd, struct pt_cache_header *header)

    88

{

    89

    size_t len = sizeof(*header);

    90

    char *buf = (char *) header;

    91

    92

    // seek to start

    93

    if (lseek(fd, 0, SEEK_SET) != 0)

    94

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

    95

    96

    // write out full header

    97

    while (len) {

    98

        ssize_t ret;

    99

   100

        // try and write out the header

   101

        if ((ret = read(fd, buf, len)) <= 0)

   102

            RETURN_ERROR(PT_ERR_CACHE_READ);

   103

   104

        // update offset

   105

        buf += ret;

   106

        len -= ret;

   107

    }

   108

   109

    // done

   110

    return 0;

   111

}

   112

   113

/**

   114

 * Read and return the version number from the cache file, temporarily opening it if needed

   115

 */

   116

static int pt_cache_version (struct pt_cache *cache)

   117

{

   118

    int fd;

   119

    struct pt_cache_header header;

   120

    int ret;

   121

   122

    // already open?

   123

    if (cache->file)

   124

        return cache->file->header.version;

   125

   126

    // temp. open

   127

    if ((ret = pt_cache_open_read_fd(cache, &fd)))

   128

        return ret;

   129

   130

    // read header

   131

    if ((ret = pt_cache_read_header(fd, &header)))

   132

        JUMP_ERROR(ret);

   133

   134

    // ok

   135

    ret = header.version;

   136

   137

error:

   138

    // close

   139

    close(fd);

   140

   141

    return ret;

   142

}

   143

   144

int pt_cache_status (struct pt_cache *cache, const char *img_path)

   145

{

   146

    struct stat st_img, st_cache;

   147

    int ver;

   148

   149

    // test original file

   150

    if (stat(img_path, &st_img) < 0)

   151

        RETURN_ERROR(PT_ERR_IMG_STAT);

   152

   153

    // test cache file

   154

    if (stat(cache->path, &st_cache) < 0) {

   155

        // always stale if it doesn't exist yet

   156

        if (errno == ENOENT)

   157

            return PT_CACHE_NONE;

   158

        else

   159

            RETURN_ERROR(PT_ERR_CACHE_STAT);

   160

    }

   161

   162

    // compare mtime

   163

    if (st_img.st_mtime > st_cache.st_mtime)

   164

        return PT_CACHE_STALE;

   165

   166

    // read version

   167

    if ((ver = pt_cache_version(cache)) < 0)

   168

        // fail

   169

        return ver;

   170

   171

    // compare version

   172

    if (ver != PT_CACHE_VERSION)

   173

        return PT_CACHE_INCOMPAT;

   174

   175

    // ok, should be in order

   176

    return PT_CACHE_FRESH;

   177

}

   178

   179

void pt_cache_info (struct pt_cache *cache, struct pt_image_info *info)

   180

{

   181

    struct stat st;

   182

   183

    if (cache->file)

   184

        // img info

   185

        pt_png_info(&cache->file->header.png, info);

   186

   187

    // stat

   188

    if (stat(cache->path, &st) < 0) {

   189

        // unknown

   190

        info->cache_mtime = 0;

   191

        info->cache_bytes = 0;

   192

        info->cache_blocks = 0;

   193

   194

    } else {

   195

        // store

   196

        info->cache_version = pt_cache_version(cache);

   197

        info->cache_mtime = st.st_mtime;

   198

        info->cache_bytes = st.st_size;

   199

        info->cache_blocks = st.st_blocks;

   200

    }

   201

}

   202

   212

/**

   213

 * Open the .tmp cache file as an fd for writing

   214

 */

   215

static int pt_cache_open_tmp_fd (struct pt_cache *cache, int *fd_ptr)

   216

{

   217

    int fd;

   218

    char tmp_path[1024];

   221

    // get .tmp path

   224

   227

        RETURN_ERROR(PT_ERR_CACHE_OPEN_TMP);

   228

   229

    // ok

   230

    *fd_ptr = fd;

   231

   232

    return 0;

   233

}

   234

   235

   236

/**

   237

 * Mmap the pt_cache_file using sizeof(struct pt_cache_file) + data_size

   238

 */

   239

static int pt_cache_open_mmap (struct pt_cache *cache, struct pt_cache_file **file_ptr, size_t data_size, bool readonly)

   240

{

   241

    int prot = 0;

   242

    void *addr;

   243

   244

    // determine prot

   245

    prot |= PROT_READ;

   246

   247

    if (!readonly) {

   248

        assert(cache->mode & PT_OPEN_UPDATE);

   249

   250

        prot |= PROT_WRITE;

   251

    }

   252

   253

    // mmap() the full file including header

   254

    if ((addr = mmap(NULL, sizeof(struct pt_cache_file) + data_size, prot, MAP_SHARED, cache->fd, 0)) == MAP_FAILED)

   255

        RETURN_ERROR(PT_ERR_CACHE_MMAP);

   256

   257

    // ok

   258

    *file_ptr = addr;

   259

   260

    return 0;

   261

}

   262

   263

int pt_cache_open (struct pt_cache *cache)

   264

{

   265

    struct pt_cache_header header;

   266

    int err;

   267

   268

    // ignore if already open

   269

    if (cache->file)

   270

        return 0;

   271

   272

    // open the .cache in readonly mode

   273

    if ((err = pt_cache_open_read_fd(cache, &cache->fd)))

   274

        return err;

   275

   276

    // read in header

   277

    if ((err = pt_cache_read_header(cache->fd, &header)))

   278

        JUMP_ERROR(err);

   279

   280

    // check version

   281

    if (header.version != PT_CACHE_VERSION)

   282

        JUMP_SET_ERROR(err, PT_ERR_CACHE_VERSION);

   283

   284

    // mmap the header + data

   285

    if ((err = pt_cache_open_mmap(cache, &cache->file, header.data_size, true)))

   286

        JUMP_ERROR(err);

   287

   288

    // done

   289

    return 0;

   290

   291

error:

   292

    // cleanup

   293

    pt_cache_abort(cache);

   294

   295

    return err;

   296

}

   297

   298

/**

   299

 * Write out the cache header into the opened file

   300

 */

   301

static int pt_cache_write_header (struct pt_cache *cache, const struct pt_cache_header *header)

   302

{

   303

    size_t len = sizeof(*header);

   304

    const char *buf = (const char *) header;

   305

   306

    // seek to start

   307

    if (lseek(cache->fd, 0, SEEK_SET) != 0)

   308

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

   309

   310

    // write out full header

   311

    while (len) {

   312

        ssize_t ret;

   313

   314

        // try and write out the header

   315

        if ((ret = write(cache->fd, buf, len)) <= 0)

   316

            RETURN_ERROR(PT_ERR_CACHE_WRITE);

   317

   318

        // update offset

   319

        buf += ret;

   320

        len -= ret;

   321

    }

   322

   323

    // done

   324

    return 0;

   325

}

   326

   327

/**

   328

 * Create a new .tmp cache file, open it, and write out the header.

   329

 */

   330

static int pt_cache_create (struct pt_cache *cache, struct pt_cache_header *header)

   331

{

   332

    int err;

   333

   335

   336

    // open as .tmp

   337

    if ((err = pt_cache_open_tmp_fd(cache, &cache->fd)))

   338

        return err;

   339

   340

    // write header

   341

    if ((err = pt_cache_write_header(cache, header)))

   342

        JUMP_ERROR(err);

   343

   344

    // grow file

   345

    if (ftruncate(cache->fd, sizeof(struct pt_cache_file) + header->data_size) < 0)

   346

        JUMP_SET_ERROR(err, PT_ERR_CACHE_TRUNC);

   347

   348

    // mmap header and data

   349

    if ((err = pt_cache_open_mmap(cache, &cache->file, header->data_size, false)))

   350

        JUMP_ERROR(err);

   351

   352

    // done

   353

    return 0;

   354

   355

error:

   356

    // cleanup

   357

    pt_cache_abort(cache);

   358

   359

    return err;

   360

}

   361

   362

/**

   363

 * Rename the opened .tmp to .cache

   364

 */

   365

static int pt_cache_create_done (struct pt_cache *cache)

   366

{

   367

    char tmp_path[1024];

   369

   370

    // get .tmp path

   373

   374

    // rename

   375

    if (rename(tmp_path, cache->path) < 0)

   376

        RETURN_ERROR(PT_ERR_CACHE_RENAME_TMP);

   377

   378

    // ok

   379

    return 0;

   380

}

   381

   405

int pt_cache_update (struct pt_cache *cache, struct pt_png_img *img, const struct pt_image_params *params)

   406

{

   407

    struct pt_cache_header header;

   408

    int err;

   417

   418

    // prep header

   419

    header.version = PT_CACHE_VERSION;

   420

    header.format = PT_IMG_PNG;

   421

   422

    // read img header

   423

    if ((err = pt_png_read_header(img, &header.png, &header.data_size)))

   424

        return err;

   425

   426

    // save any params

   427

    if (params)

   428

        header.params = *params;

   429

   430

    // create/open .tmp and write out header

   431

    if ((err = pt_cache_create(cache, &header)))

   432

        return err;

   433

   434

    // decode to disk

   435

    if ((err = pt_png_decode(img, &cache->file->header.png, &cache->file->header.params, cache->file->data)))

   437

   438

    // done, commit .tmp

   439

    if ((err = pt_cache_create_done(cache)))

   443

   449

}

   450

   451

int pt_cache_tile (struct pt_cache *cache, struct pt_tile *tile)

   452

{

   453

    int err;

   454

   455

    // ensure open

   456

    if ((err = pt_cache_open(cache)))

   457

        return err;

   458

   459

    // render

   460

    if ((err = pt_png_tile(&cache->file->header.png, cache->file->data, tile)))

   461

        return err;

   462

   463

    return 0;

   464

}

   465

   466

int pt_cache_close (struct pt_cache *cache)

   467

{

   468

    if (cache->file != NULL) {

   469

        if (munmap(cache->file, sizeof(struct pt_cache_file) + cache->file->header.data_size))

   470

            RETURN_ERROR(PT_ERR_CACHE_MUNMAP);

   471

   472

        cache->file = NULL;

   473

    }

   474

   475

    if (cache->fd >= 0) {

   476

        if (close(cache->fd))

   477

            RETURN_ERROR(PT_ERR_CACHE_CLOSE);

   478

   479

        cache->fd = -1;

   480

    }

   481

   482

    return 0;

   483

}

   484

   485

void pt_cache_destroy (struct pt_cache *cache)

   486

{

   487

    // cleanup

   488