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 <string.h>

     8

#include <unistd.h>

     9

#include <sys/types.h>

    10

#include <sys/stat.h>

    11

#include <fcntl.h>

    12

#include <sys/mman.h>

    13

#include <errno.h>

    14

#include <assert.h>

    15

    16

    17

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

    18

{

    19

    struct pt_cache *cache;

    20

    int err;

    21

    22

    // alloc

    23

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

    24

        RETURN_ERROR(PT_ERR_MEM);

    25

    26

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

    27

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    28

    29

    // init

    30

    cache->fd = -1;

    31

    cache->mode = mode;

    32

    33

    // ok

    34

    *cache_ptr = cache;

    35

    36

    return 0;

    37

    38

error:

    39

    // cleanup

    40

    if (cache)

    41

        pt_cache_destroy(cache);

    42

    43

    return err;

    44

}

    45

    46

/**

    47

 * Force-clean pt_cache, warn on errors

    48

 */

    49

static void pt_cache_abort (struct pt_cache *cache)

    50

{

    51

    if (cache->file != NULL) {

    52

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

    53

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

    54

    55

        cache->file = NULL;

    56

    }

    57

    58

    if (cache->fd >= 0) {

    59

        if (close(cache->fd))

    60

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

    61

    62

        cache->fd = -1;

    63

    }

    64

}

    65

    66

/**

    67

 * Open the cache file as an fd for reading

    68

 */

    69

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

    70

{

    71

    int fd;

    72

    73

    // actual open()

    74

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

    75

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

    76

    77

    // ok

    78

    *fd_ptr = fd;

    79

    80

    return 0;

    81

}

    82

    83

/**

    84

 * Read in the cache header from the open file

    85

 */

    86

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

    87

{

    88

    size_t len = sizeof(*header);

    89

    char *buf = (char *) header;

    90

    91

    // seek to start

    92

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

    93

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

    94

    95

    // write out full header

    96

    while (len) {

    97

        ssize_t ret;

    98

    99

        // try and write out the header

   100

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

   101

            RETURN_ERROR(PT_ERR_CACHE_READ);

   102

   103

        // update offset

   104

        buf += ret;

   105

        len -= ret;

   106

    }

   107

   108

    // done

   109

    return 0;

   110

}

   111

   112

/**

   113

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

   114

 */

   115

static int pt_cache_version (struct pt_cache *cache)

   116

{

   117

    int fd;

   118

    struct pt_cache_header header;

   119

    int ret;

   120

   121

    // already open?

   122

    if (cache->file)

   123

        return cache->file->header.version;

   124

   125

    // temp. open

   126

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

   127

        return ret;

   128

   129

    // read header

   130

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

   131

        JUMP_ERROR(ret);

   132

   133

    // ok

   134

    ret = header.version;

   135

   136

error:

   137

    // close

   138

    close(fd);

   139

   140

    return ret;

   141

}

   142

   143

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

   144

{

   145

    struct stat st_img, st_cache;

   146

    int ver;

   147

   148

    // test original file

   149

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

   150

        RETURN_ERROR(PT_ERR_IMG_STAT);

   151

   152

    // test cache file

   153

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

   154

        // always stale if it doesn't exist yet

   155

        if (errno == ENOENT)

   156

            return PT_CACHE_NONE;

   157

        else

   158

            RETURN_ERROR(PT_ERR_CACHE_STAT);

   159

    }

   160

   161

    // compare mtime

   162

    if (st_img.st_mtime > st_cache.st_mtime)

   163

        return PT_CACHE_STALE;

   164

   165

    // read version

   166

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

   167

        // fail

   168

        return ver;

   169

   170

    // compare version

   171

    if (ver != PT_CACHE_VERSION)

   172

        return PT_CACHE_INCOMPAT;

   173

   174

    // ok, should be in order

   175

    return PT_CACHE_FRESH;

   176

}

   177

   178

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

   179

{

   180

    struct stat st;

   181

   182

    if (cache->file)

   183

        // img info

   184

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

   185

   186

    // stat

   187

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

   188

        // unknown

   189

        info->cache_mtime = 0;

   190

        info->cache_bytes = 0;

   191

        info->cache_blocks = 0;

   192

   193

    } else {

   194

        // store

   195

        info->cache_version = pt_cache_version(cache);

   196

        info->cache_mtime = st.st_mtime;

   197

        info->cache_bytes = st.st_size;

   198

        info->cache_blocks = st.st_blocks;

   199

    }

   200

}

   201

   202

static int pt_cache_tmp_name (struct pt_cache *cache, char tmp_path[], size_t tmp_len)

   203

{

   204

    // get .tmp path

   205

    if (path_with_fext(cache->path, tmp_path, tmp_len, ".tmp"))

   206

        RETURN_ERROR(PT_ERR_PATH);

   207

   208

    return 0;

   209

}

   210

   211

/**

   212

 * Compute and return the full size of the .cache file

   213

 */

   214

static size_t pt_cache_size (size_t data_size)

   215

{

   216

    assert(sizeof(struct pt_cache_file) == PT_CACHE_HEADER_SIZE);

   217

   218

    return sizeof(struct pt_cache_file) + data_size;

   219

}

   220

   221

/**

   222

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

   223

 */

   224

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

   225

{

   226

    int fd;

   227

    char tmp_path[1024];

   228

    int err;

   229

   230

    // get .tmp path

   231

    if ((err = pt_cache_tmp_name(cache, tmp_path, sizeof(tmp_path))))

   232

        return err;

   233

   234

    // open for write, create, fail if someone else already opened it for update

   235

    if ((fd = open(tmp_path, O_RDWR | O_CREAT | O_EXCL, 0644)) < 0)

   236

        RETURN_ERROR(PT_ERR_CACHE_OPEN_TMP);

   237

   238

    // ok

   239

    *fd_ptr = fd;

   240

   241

    return 0;

   242

}

   243

   244

   245

/**

   246

 * Mmap the pt_cache_file using pt_cache_size(data_size)

   247

 */

   248

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

   249

{

   250

    int prot = 0;

   251

    void *addr;

   252

   253

    // determine prot

   254

    prot |= PROT_READ;

   255

   256

    if (!readonly) {

   257

        assert(cache->mode & PT_OPEN_UPDATE);

   258

   259

        prot |= PROT_WRITE;

   260

    }

   261

   262

    // mmap() the full file including header

   263

    if ((addr = mmap(NULL, pt_cache_size(data_size), prot, MAP_SHARED, cache->fd, 0)) == MAP_FAILED)

   264

        RETURN_ERROR(PT_ERR_CACHE_MMAP);

   265

   266

    // ok

   267

    *file_ptr = addr;

   268

   269

    return 0;

   270

}

   271

   272

int pt_cache_open (struct pt_cache *cache)

   273

{

   274

    struct pt_cache_header header;

   275

    int err;

   276

   277

    // ignore if already open

   278

    if (cache->file)

   279

        return 0;

   280

   281

    // open the .cache in readonly mode

   282

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

   283

        return err;

   284

   285

    // read in header

   286

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

   287

        JUMP_ERROR(err);

   288

   289

    // check version

   290

    if (header.version != PT_CACHE_VERSION)

   291

        JUMP_SET_ERROR(err, PT_ERR_CACHE_VERSION);

   292

   293

    // mmap the header + data

   294

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

   295

        JUMP_ERROR(err);

   296

   297

    // done

   298

    return 0;

   299

   300

error:

   301

    // cleanup

   302

    pt_cache_abort(cache);

   303

   304

    return err;

   305

}

   306

   307

/**

   308

 * Write out the cache header into the opened file

   309

 */

   310

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

   311

{

   312

    size_t len = sizeof(*header);

   313

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

   314

   315

    // seek to start

   316

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

   317

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

   318

   319

    // write out full header

   320

    while (len) {

   321

        ssize_t ret;

   322

   323

        // try and write out the header

   324

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

   325

            RETURN_ERROR(PT_ERR_CACHE_WRITE);

   326

   327

        // update offset

   328

        buf += ret;

   329

        len -= ret;

   330

    }

   331

   332

    // done

   333

    return 0;

   334

}

   335

   336

/**

   337

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

   338

 */

   339

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

   340

{

   341

    int err;

   342

   343

    assert(cache->mode & PT_OPEN_UPDATE);

   344

   345

    // open as .tmp

   346

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

   347

        return err;

   348

   349

    // write header

   350

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

   351

        JUMP_ERROR(err);

   352

   353

    // grow file

   354

    if (ftruncate(cache->fd, pt_cache_size(header->data_size)) < 0)

   355

        JUMP_SET_ERROR(err, PT_ERR_CACHE_TRUNC);

   356

   357

    // mmap header and data

   358

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

   359

        JUMP_ERROR(err);

   360

   361

    // done

   362

    return 0;

   363

   364

error:

   365

    // cleanup

   366

    pt_cache_abort(cache);

   367

   368

    return err;

   369

}

   370

   371

/**

   372

 * Rename the opened .tmp to .cache

   373

 */

   374

static int pt_cache_create_done (struct pt_cache *cache)

   375

{

   376

    char tmp_path[1024];

   377

    int err;

   378

   379

    // get .tmp path

   380

    if ((err = pt_cache_tmp_name(cache, tmp_path, sizeof(tmp_path))))

   381

        return err;

   382

   383

    // rename

   384

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

   385

        RETURN_ERROR(PT_ERR_CACHE_RENAME_TMP);

   386

   387

    // ok

   388

    return 0;

   389

}

   390

   391

/**

   392

 * Abort a failed cache update after cache_create

   393

 */

   394

static void pt_cache_create_abort (struct pt_cache *cache)

   395

{

   396

    char tmp_path[1024];

   397

    int err;

   398

   399

    // close open stuff

   400

    pt_cache_abort(cache);

   401

   402

    // get .tmp path

   403

    if ((err = pt_cache_tmp_name(cache, tmp_path, sizeof(tmp_path)))) {

   404

        log_warn_errno("pt_cache_tmp_name: %s: %s", cache->path, pt_strerror(err));

   405

   406

        return;

   407

    }

   408

   409

    // remove .tmp

   410

    if (unlink(tmp_path))

   411

        log_warn_errno("unlink: %s", tmp_path);

   412

}

   413

   414

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

   415

{

   416

    struct pt_cache_header header;

   417

    int err;

   418

   419

    // check mode

   420

    if (!(cache->mode & PT_OPEN_UPDATE))

   421

        RETURN_ERROR(PT_ERR_OPEN_MODE);

   422

   423

    // close if open

   424

    if ((err = pt_cache_close(cache)))

   425

        return err;

   426

   427

    // prep header

   428

    header.version = PT_CACHE_VERSION;

   429

    header.format = PT_IMG_PNG;

   430

   431

    // read img header

   432

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

   433

        return err;

   434

   435

    // save any params

   436

    if (params)

   437

        header.params = *params;

   438

   439

    // create/open .tmp and write out header

   440

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

   441

        return err;

   442

   443

    // decode to disk

   444

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

   445

        goto error;

   446

   447

    // done, commit .tmp

   448

    if ((err = pt_cache_create_done(cache)))

   449

        goto error;

   450

   451

    return 0;

   452

   453

error:

   454

    // cleanup .tmp

   455

    pt_cache_create_abort(cache);

   456

   457

    return err;

   458

}

   459

   460

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

   461

{

   462

    int err;

   463

   464

    // ensure open

   465

    if ((err = pt_cache_open(cache)))

   466

        return err;

   467

   468

    // render

   469

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

   470

        return err;

   471

   472

    return 0;

   473

}

   474

   475

int pt_cache_close (struct pt_cache *cache)

   476

{

   477

    if (cache->file != NULL) {

   478

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

   479

            RETURN_ERROR(PT_ERR_CACHE_MUNMAP);

   480

   481

        cache->file = NULL;

   482

    }

   483

   484

    if (cache->fd >= 0) {

   485

        if (close(cache->fd))

   486

            RETURN_ERROR(PT_ERR_CACHE_CLOSE);

   487